lincd-cli 0.1.23 → 0.2.0

package/lib/cli.js

@@ -72,6 +72,7 @@ var path = require('path');
 var glob = require('glob');
 var variables = {};
 var open = require('open');
+var gruntConfig;
 program
     .command('create-app')
     .action(function (name) {
@@ -80,19 +81,19 @@ program
     .description('Creates a new folder with all the required files for a LINCD app')
     .argument('<name>', 'the name of your LINCD app. To use spaces, wrap the name in double quotes.');
 program
-    .command('create-module')
+    .command('create-package')
     .action(function (name, uriBase) {
-    return createModule(name, uriBase);
+    return createPackage(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');
+    .description('Create a new folder with all the required files for a new LINCD package')
+    .argument('<name>', 'The name of the package. Will be used as package name in package.json')
+    .argument('[uri_base]', 'The base URL used for data of this package. Leave blank to use the URL of your package 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.')
+    .description('Creates a new ShapeClass file for your package. Execute this from your package folder.')
     .argument('<name>', 'The name of the shape. Will be used for the file name and the class name');
 program
     .command('create-component')
@@ -106,9 +107,9 @@ program
     .action(function (prefix, uriBase) {
     return createOntology(prefix, uriBase);
 })
-    .description('Creates a new ontology file for your module. Execute this from your module folder.')
+    .description('Creates a new ontology file for your package. Execute this from your package 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");
+    .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 package");
 program.command('register-local', { hidden: true }).action(function () {
     register('http://localhost:4101');
 });
@@ -120,7 +121,7 @@ program
     .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');
+    .description('Register (a new version of) this package to the LINCD registry. If successful your package will appear on www.lincd.org');
 program
     .command('info')
     .action(function () {
@@ -130,13 +131,15 @@ program
 })
     .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);
+    buildPackage(target, target2);
 });
 program.command('publish-updated').action(function () {
     return publishUpdated();
 });
 program.command('status').action(function () {
+    //log which packages need to be published
     return publishUpdated(true).then(function () {
+        //log which packages need to be build
         return buildUpdated(undefined, '', '', true);
     });
 });
@@ -149,17 +152,17 @@ program.command('build-updated-since [num-commits-back] [target] [target2]').act
 program.command('build-all [target] [target2]').action(function (target, target2) {
     buildAll(target, target2);
 });
-program.command('modules [action] [filter] [filter-value]').action(function (command, filter, filterValue) {
-    executeCommandForEachModule(getLincdModules(), command, filter, filterValue);
+program.command('all [action] [filter] [filter-value]').action(function (command, filter, filterValue) {
+    executeCommandForEachPackage(getLincdPackages(), command, filter, filterValue);
 });
-// program.command('modules-except [excludedSpaces] [action]').action((excludedSpaces, command) => {
+// program.command('all-except [excludedSpaces] [action]').action((excludedSpaces, command) => {
 //   executeCommandForEachModule(getLincdModules(), command, null, excludedSpaces);
 // });
 program.command('dev [target] [mode]').action(function (target, mode) {
-    developModule(target, mode);
+    developPackage(target, mode);
 });
 program
-    .command('module|m')
+    .command('module|m|package|p|pkg')
     .action(function (name, command, args) {
     var fullCommand = command
         ? command +
@@ -170,11 +173,11 @@ program
                 .filter(function (a) { return a && true; })
                 .join(' ')
         : null;
-    executeCommandForModule(name, fullCommand);
+    executeCommandForPackage(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.')
+    .description('Searches for a package in this workspace with a partially matching name and executes a command for that package (without needing to execute it from the folder of the package)')
+    .argument('<name>', 'the name of the package. 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() {
@@ -189,6 +192,33 @@ function log() {
         console.log(chalk.cyan('Info: ') + message);
     });
 }
+function progressUpdate(message) {
+    process.stdout.write('                                                                    \r');
+    process.stdout.write(message + '\r');
+}
+function debugInfo() {
+    var messages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        messages[_i] = arguments[_i];
+    }
+    // messages.forEach((message) => {
+    //   console.log(chalk.cyan('Info: ') + message);
+    // });
+    //@TODO: let packages also use lincd.config.json? instead of gruntfile...
+    // that way we can read "analyse" here and see if we need to log debug info
+    // if(!gruntConfig)
+    // {
+    //   gruntConfig = getGruntConfig();
+    //   console.log(gruntConfig);
+    //   process.exit();
+    // }
+    // if(gruntConfig.analyse === true)
+    // {
+    //   messages.forEach((message) => {
+    //     console.log(chalk.cyan('Info: ') + message);
+    //   });
+    // }
+}
 function warn() {
     var messages = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -199,7 +229,7 @@ function warn() {
         // console.log(chalk.red(message));
     });
 }
-function developModule(target, mode) {
+function developPackage(target, mode) {
     if (!target)
         target = 'es6';
     if (mode !== 'production')
@@ -231,252 +261,270 @@ function checkWorkspaces(rootPath, workspaces, res) {
                 var folders = fs.readdirSync(workspacePath);
                 folders.forEach(function (folder) {
                     if (folder !== './' && folder !== '../') {
-                        checkModulePath(rootPath, path.join(workspacePath, folder), res);
+                        checkPackagePath(rootPath, path.join(workspacePath, folder), res);
                     }
                 });
             }
         }
         else {
-            checkModulePath(rootPath, workspacePath, res);
+            checkPackagePath(rootPath, workspacePath, res);
         }
     });
 }
-function checkModulePath(rootPath, modulePath, res) {
-    var packagePath = path.join(modulePath, 'package.json');
+function checkPackagePath(rootPath, packagePath, res) {
+    var packageJsonPath = path.join(packagePath, 'package.json');
     // console.log('checking '+packagePath);
-    if (fs.existsSync(packagePath)) {
-        var pack = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-        //some packages are not true lincd modules, but we still want them to be re-built automatically. This is what lincd_util is for
+    if (fs.existsSync(packageJsonPath)) {
+        var pack = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        //some packages are not true lincd packages, but we still want them to be re-built automatically. This is what lincd_util is for
         if (pack && pack.workspaces) {
-            checkWorkspaces(modulePath, pack.workspaces, res);
+            checkWorkspaces(packagePath, pack.workspaces, res);
         }
         else if (pack && pack.lincd === true) {
             res.push({
-                path: modulePath,
-                moduleName: pack.name,
+                path: packagePath,
                 packageName: pack.name
             });
         }
     }
 }
-function buildAll(target, target2) {
+function runOnPackagesGroupedByDependencies(lincdPackages, onBuildStack, onStackEnd) {
     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);
+    //get dependencies of each package
+    var leastDependentPackage;
+    lincdPackages.forEach(function (pkg) {
+        var pack = (0, utils_1.getPackageJSON)(pkg.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); })
+            //get lincd related dependencies and get the actual package details from the package map by removing '@dacore/' from the package name
+            var packageDependencies = Object.keys(pack.dependencies)
+                .filter(function (dependency) { return lincdPackages.has(dependency); })
                 .map(function (dependency) {
-                return modules.has(dependency) ? modules.get(dependency) : dependency;
+                return lincdPackages.has(dependency) ? lincdPackages.get(dependency) : dependency;
             });
-            // console.log(module.moduleName,moduleDependencies.map())
-            dependencies.set(module, moduleDependencies);
+            // console.log(package.packageName,packageDependencies.map())
+            dependencies.set(pkg, packageDependencies);
         }
     });
-    dependencies.forEach(function (moduleDependencies, module) {
-        if (!moduleDependencies.some(function (dependency) {
-            return typeof dependency !== 'string' && modules.has(dependency.moduleName);
+    dependencies.forEach(function (PackageDependencies, pkg) {
+        if (!PackageDependencies.some(function (dependency) {
+            return typeof dependency !== 'string' && lincdPackages.has(dependency.packageName);
         })) {
-            leastDependentModule = module;
+            leastDependentPackage = pkg;
         }
     });
-    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 startStack = [leastDependentPackage];
     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;
+    var results = [];
+    var runStack = function (stack) { return __awaiter(_this, void 0, void 0, function () {
+        var runFunction, stackPromise, stackResults;
         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) {
+                    runFunction = onBuildStack(stack, dependencies);
+                    stackPromise = Promise.all(stack.map(function (pck) {
                         // 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);
-                                printBuildResults(failedModules, done);
-                                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);
-                            }
+                        return runFunction(pck)["catch"](function (_a) {
+                            var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+                            warn('Uncaught exception whilst running parallel function on ' + pck.packageName, error.message);
+                            // warn(chalk.red(pck.packageName+' failed:'));
+                            // console.log(stdout);
                         })
                             .then(function (res) {
-                            // console.log("RESULT: ",res);
-                            // if(res && res.includes("Aborted due to warnings"))
-                            // {
-                            //   failedModules.push(module.moduleName);
-                            // }
-                            // else
-                            // {
-                            done.add(module);
-                            // }
-                            modulesLeft--;
-                            log(chalk.magenta(modulesLeft + ' modules left'));
-                            if (modulesLeft == 0) {
-                                printBuildResults(failedModules, done);
-                            }
+                            done.add(pck);
                             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;
+                    stackResults = _a.sent();
+                    results = results.concat(stackResults);
                     //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
+                    //find those packages who have all their dependencies already built and add them to the stack
+                    lincdPackages.forEach(function (pkg) {
+                        var deps = dependencies.get(pkg);
+                        //if the package 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) &&
+                        if (!done.has(pkg) &&
                             deps.every(function (dependency) {
-                                return typeof dependency !== 'string' && (done.has(dependency) || !modules.has(dependency.moduleName));
+                                return typeof dependency !== 'string' && (done.has(dependency) || !lincdPackages.has(dependency.packageName));
                             })) {
-                            stack.push(module);
+                            stack.push(pkg);
                         }
-                        // else if(!done.has(module))
+                        // else if(!done.has(package))
                         // {
-                        // 	console.log(chalk.red(module+' not yet'))
+                        // 	console.log(chalk.red(package+' 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()];
+                        return [2 /*return*/, runStack(stack)];
                     }
                     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?'));
-                                    }
-                                }
-                            });
-                        }
+                        onStackEnd(results.filter(Boolean));
                     }
                     return [2 /*return*/];
             }
         });
     }); };
     //starts the process
-    runStack();
+    runStack(startStack);
+}
+function buildAll(target, target2) {
+    var _this = this;
+    console.log('Building all LINCD packages of this repository in order of dependencies');
+    var lincdPackages = getLocalLincdPackageMap();
+    var startFrom;
+    //by default start building
+    var building = true;
+    //option to start from a specific package 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));
+        return function (pkg) { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/];
+        }); }); };
+    }
+    var done = new Set();
+    var failedModules = [];
+    progressUpdate(lincdPackages.size + ' packages left');
+    var packagesLeft = lincdPackages.size;
+    // let packagesLeft = lincdPackages.size - done.size;
+    runOnPackagesGroupedByDependencies(lincdPackages, function (packageGroup, dependencies) {
+        if (done.size > 0) {
+            debugInfo(chalk.magenta('\n-------\nThese packages are next, since all their dependencies have now been build:'));
+            // log(stack);
+        }
+        debugInfo('Now building: ' + chalk.blue(packageGroup.map(function (i) { return i.packageName; })));
+        return function (pkg) { return __awaiter(_this, void 0, void 0, function () {
+            var command;
+            return __generator(this, function (_a) {
+                //if we're skipping builds until a certain package
+                if (!building) {
+                    //if the package name matches the package we're supposed to start from then start building packages
+                    if (pkg.packageName == startFrom || pkg.packageName == startFrom) {
+                        building = true;
+                    }
+                    //else still waiting for the package
+                    else {
+                        log(chalk.blue('skipping ' + pkg.packageName));
+                        command = Promise.resolve(true);
+                    }
+                }
+                //unless told otherwise, build the package
+                if (!command) {
+                    command = execPromise('cd ' + pkg.path + ' && yarn lincd build' + (target ? ' ' + target : '') + (target2 ? ' ' + target2 : ''), false, false, {}, false);
+                    debugInfo(chalk.cyan('Building ' + pkg.packageName));
+                }
+                return [2 /*return*/, command["catch"](function (_a) {
+                        var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+                        //this prints out the webpack output, including the build errors
+                        warn('Failed to build ' + pkg.packageName);
+                        console.log(stdout);
+                        failedModules.push(pkg.packageName);
+                        var dependentModules = getDependentPackages(dependencies, pkg);
+                        if (dependentModules.length > 0) {
+                            printBuildResults(failedModules, done);
+                            console.log(chalk.magenta('Stopping build process because an error occurred whilst building ' +
+                                pkg.packageName +
+                                ', which ' +
+                                dependentModules.length +
+                                ' other packages depend on.')); //"+dependentModules.map(d => d.packageName).join(", ")));
+                            console.log(chalk.cyanBright('tip ') +
+                                'Run ' +
+                                chalk.green("lincd build-all from ".concat(pkg.packageName)) +
+                                ' to build only the remaining packages'); //"+dependentModules.map(d => d.packageName).join(", ")));
+                            process.exit(1);
+                        }
+                    })
+                        .then(function (res) {
+                        done.add(pkg);
+                        packagesLeft--;
+                        // log(chalk.magenta(packagesLeft + ' packages left'));
+                        process.stdout.write(packagesLeft + ' packages left\r');
+                        if (packagesLeft == 0) {
+                            printBuildResults(failedModules, done);
+                        }
+                        return res;
+                    })];
+            });
+        }); };
+    }, function (dependencies) {
+        //if no more packages to build but we never started building...
+        if (!building) {
+            console.log(chalk.red('Could not find the package to start from. Please provide a correct package name or package name to build from'));
+        }
+        else {
+            //Detecting cyclical dependencies that caused some packages not to be build
+            var first_1 = true;
+            lincdPackages.forEach(function (pkg) {
+                if (!done.has(pkg)) {
+                    var deps = dependencies.get(pkg);
+                    if (first_1) {
+                        console.log(chalk.red('CYCLICAL DEPENDENCIES? - could not build some packages because they depend on each other.'));
+                        first_1 = false;
+                    }
+                    //print the cyclical dependencies
+                    console.log(chalk.red(pkg.packageName) +
+                        ' depends on ' +
+                        deps
+                            .filter(function (dependency) {
+                            return typeof dependency !== 'string';
+                        })
+                            .map(function (d) {
+                            return done.has(d) ? d.packageName : chalk.red(d.packageName);
+                        })
+                            .join(', '));
+                    //also print some information why these packages 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 package(s) - which seem not to be proper packages :' +
+                            stringDependencies.join(', ')));
+                        console.log(chalk.red('Could you remove this from dependencies? Should it be a devDependency?'));
+                    }
+                }
+            });
+        }
+    });
+}
+function getDependentPackages(dependencies, pkg) {
+    var dependentModules = [];
+    dependencies.forEach(function (dModuleDependencies, dModule) {
+        if (dModuleDependencies.indexOf(pkg) !== -1) {
+            dependentModules.push(dModule);
+        }
+    });
+    return dependentModules;
 }
 /**
- * Returns a map of the modules that this repository manages (so no modules found through the workspaces who's path contains ../ )
+ * Returns a map of the packages that this repository manages (so no packages found through the workspaces who's path contains ../ )
  * @param rootPath
  */
-function getLocalLincdModuleMap(rootPath) {
+function getLocalLincdPackageMap(rootPath) {
     if (rootPath === void 0) { rootPath = './'; }
     var map = new Map();
-    getLincdModules(rootPath).forEach(function (module) {
-        if (module.path.indexOf('../') === -1 && module.path.indexOf('..\\') === -1) {
-            // console.log(module.path);
-            map.set(module.moduleName, module);
+    getLincdPackages(rootPath).forEach(function (pkg) {
+        if (pkg.path.indexOf('../') === -1 && pkg.path.indexOf('..\\') === -1) {
+            // console.log(package.path);
+            map.set(pkg.packageName, pkg);
         }
     });
     return map;
 }
 function getLocalLincdModules(rootPath) {
     if (rootPath === void 0) { rootPath = './'; }
-    return getLincdModules(rootPath).filter(function (module) {
-        return module.path.indexOf('..\\') === -1;
+    return getLincdPackages(rootPath).filter(function (pkg) {
+        return pkg.path.indexOf('..\\') === -1;
     });
 }
-function getLincdModules(rootPath) {
+function getLincdPackages(rootPath) {
     if (rootPath === void 0) { rootPath = process.cwd(); }
     var pack = (0, utils_1.getPackageJSON)();
     if (!pack || !pack.workspaces) {
@@ -558,16 +606,17 @@ function execp(cmd, log, allowError, options) {
         });
     });
 }
-function execPromise(command, log, allowError, options) {
+function execPromise(command, log, allowError, options, pipeOutput) {
     if (log === void 0) { log = false; }
     if (allowError === void 0) { allowError = false; }
+    if (pipeOutput === void 0) { pipeOutput = false; }
     return new Promise(function (resolve, reject) {
         if (log)
             console.log(chalk.cyan(command));
-        exec(command, options, function (error, stdout, stderr) {
+        var child = exec(command, options, function (error, stdout, stderr) {
             if (error) {
                 if (!allowError) {
-                    reject(error.message);
+                    reject({ error: error, stdout: stdout, stderr: stderr });
                     return;
                 }
                 else if (log) {
@@ -583,6 +632,10 @@ function execPromise(command, log, allowError, options) {
             }
             resolve(result);
         });
+        if (pipeOutput) {
+            child.stdout.pipe(process.stdout);
+            child.stderr.pipe(process.stderr);
+        }
     });
 }
 var replaceVariablesInFile = function (filePath) { return __awaiter(void 0, void 0, void 0, function () {
@@ -606,9 +659,7 @@ var replaceCurlyVariables = function (string) {
 };
 var capitalize = function (str) { return str.charAt(0).toUpperCase() + str.toLowerCase().slice(1); };
 var camelCase = function (str) {
-    var string = str
-        .replace(/[^A-Za-z0-9]/g, ' ')
-        .split(' ');
+    var string = str.replace(/[^A-Za-z0-9]/g, ' ').split(' ');
     if (string.length > 1) {
         return string.reduce(function (result, word) { return result + capitalize(word); });
     }
@@ -634,11 +685,11 @@ var createOntology = function (prefix, uriBase, basePath) {
                     //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);
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'package', '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);
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'package', 'src', 'data', 'example-ontology.json'), targetDataFile);
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'package', 'src', 'data', 'example-ontology.json.d.ts'), targetDataFile2);
                     return [4 /*yield*/, replaceVariablesInFiles(targetFile, targetDataFile, targetDataFile2)];
                 case 1:
                     _b.sent();
@@ -729,7 +780,7 @@ var ensureFolderExists = function () {
         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`,
+          `Please run this command from the root of your package. This command expects ${parentDirectory.toString()} to exists from that folder`,
         );
       }
     }
@@ -737,7 +788,7 @@ var ensureFolderExists = function () {
 };
 var setNameVariables = function (name) {
     var hyphenName = name.replace(/[-_\s]+/g, '-');
-    var camelCaseName = camelCase(name); //some-module --> someModule
+    var camelCaseName = camelCase(name); //some-package --> someModule
     var underscoreName = name.replace(/[-\s]+/g, '_');
     //longer similar variables names should come before the shorter ones
     setVariable('underscore_name', underscoreName);
@@ -798,7 +849,7 @@ var createComponent = function (name, basePath) {
         });
     });
 };
-var createModule = function (name, uriBase, basePath) {
+var createPackage = 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;
@@ -806,9 +857,9 @@ var createModule = function (name, uriBase, basePath) {
             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');
+                    //so we manually find a packages folder, if it exists we go into that.
+                    if (fs.existsSync(path.join(basePath, 'packages'))) {
+                        basePath = path.join(basePath, 'packages');
                     }
                     if (!name) {
                         console.warn('Please provide a name as the first argument');
@@ -825,13 +876,13 @@ var createModule = function (name, uriBase, basePath) {
                     // --> 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);
+                    //but save full scoped package name under ${package_name}
+                    setVariable('package_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);
+                    log("Creating new LINCD package '" + name + "'");
+                    fs.copySync(path.join(__dirname, '..', 'defaults', 'package'), targetFolder);
                     //replace variables in some of the copied files
                     return [4 /*yield*/, Promise.all([
                             'src/index.ts',
@@ -849,7 +900,7 @@ var createModule = function (name, uriBase, basePath) {
                 case 1:
                     //replace variables in some of the copied files
                     _c.sent();
-                    //rename these to a file name similar to the module name
+                    //rename these to a file name similar to the pkg name
                     [
                         'src/ontologies/example-ontology.ts',
                         'src/data/example-ontology.json',
@@ -874,7 +925,7 @@ var createModule = function (name, uriBase, basePath) {
                         })];
                 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"));
+                    log("Prepared a new LINCD package 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*/];
             }
         });
@@ -945,7 +996,7 @@ var buildFailed = function (output) {
         var pack = JSON.parse(
             fs.readFileSync(process.cwd() + '/package.json', 'utf8'),
         );
-        let moduleName = pack.name;
+        let packageName = pack.name;
 
         //just making sure the library is loaded in correct order because circular references are currently happening when importing BlankNode before NamedNode for example
         // require('lincd');
@@ -956,12 +1007,12 @@ var buildFailed = function (output) {
             let shapeJSONLD = await getShapesJSONLD(indexExports.packageExports);
             console.log(indexExports.packageExports);
             console.log(shapeJSONLD);
-            console.log(chalk.bold(chalk.green(moduleName+'/dist/shapes.json')));
+            console.log(chalk.bold(chalk.green(packageName+'/dist/shapes.json')));
             return fs.writeFile(path.join('dist', 'shapes.json'), shapeJSONLD);
         }
         else
         {
-            console.warn("Invalid LINCD module. Index file should export a packageExports object. See examples.")
+            console.warn("Invalid LINCD package. Index file should export a packageExports object. See examples.")
         }
 
     } else {
@@ -972,7 +1023,7 @@ 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 packageName = pack.name;
         // let author = pack.author;
         // let description = pack.description;
         //
@@ -980,14 +1031,14 @@ var register = function (registryURL) {
         // if (pack.author.name) {
         //   authorName = pack.author.name;
         // }
-        console.log(chalk.cyan('registering package ' + moduleName + ' ' + version + ' in the LINCD registry'));
+        console.log(chalk.cyan('registering package ' + packageName + ' ' + version + ' in the LINCD registry'));
         return fetch(registryURL + '/register', {
             method: 'POST',
             headers: {
                 Accept: 'application/json, text/plain, */*',
                 'Content-Type': 'application/json'
             },
-            body: JSON.stringify({ package: moduleName, version: version })
+            body: JSON.stringify({ package: packageName, version: version })
         })
             .then(function (res) { return res.json(); })
             .then(function (json) {
@@ -1008,12 +1059,12 @@ var register = function (registryURL) {
         console.warn(chalk.red('Warning:') + ' not found: ' + process.cwd() + '/package.json');
     }
 };
-var buildModule = function (target, target2, modulePath, logResults) {
-    if (modulePath === void 0) { modulePath = process.cwd(); }
+var buildPackage = function (target, target2, packagePath, logResults) {
+    if (packagePath === void 0) { packagePath = process.cwd(); }
     if (logResults === void 0) { logResults = true; }
     if (target == 'production' || target == 'es5' || target == 'es6' || !target) {
-        if (!fs.existsSync(path.join(modulePath, 'Gruntfile.js'))) {
-            console.warn("No Gruntfile found at ".concat(modulePath, "\\Gruntfile.js. Cannot build."));
+        if (!fs.existsSync(path.join(packagePath, 'Gruntfile.js'))) {
+            console.warn("No Gruntfile found at ".concat(packagePath, "\\Gruntfile.js. Cannot build."));
             return;
         }
         var nodeEnv = '';
@@ -1041,7 +1092,7 @@ var buildModule = function (target, target2, modulePath, logResults) {
             ' --color');
         var method = logResults ? execp : execPromise;
         //execute the command to build the method, and provide the current work directory as option
-        return method(nodeEnv + 'grunt build' + (target ? '-' + target : '') + (target2 ? '-' + target2 : '') + ' --color', false, false, { cwd: modulePath })["catch"](function (err) {
+        return method(nodeEnv + 'grunt build' + (target ? '-' + target : '') + (target2 ? '-' + target2 : '') + ' --color', false, false, { cwd: packagePath })["catch"](function (err) {
             process.exit(1);
         });
     }
@@ -1049,21 +1100,26 @@ var buildModule = function (target, target2, modulePath, logResults) {
         console.warn('unknown build target. Use es5, es6 or production.');
     }
 };
-var getLastBuildTime = function (modulePath) {
-    return getLastModifiedFile(modulePath + '/@(builds|lib)/**/*.js');
+var getLastBuildTime = function (packagePath) {
+    return getLastModifiedFile(packagePath + '/@(builds|lib|dist)/**/*.js');
 };
-var getLastModifiedSourceTime = function (modulePath) {
-    return getLastModifiedFile(modulePath + '/@(src|data|scss)/**/*', {
-        ignore: [modulePath + '/**/*.scss.json', modulePath + '/**/*.d.ts']
+var getLastModifiedSourceTime = function (packagePath) {
+    return getLastModifiedFile(packagePath + '/@(src|data|scss)/**/*', {
+        ignore: [packagePath + '/**/*.scss.json', packagePath + '/**/*.d.ts']
     });
 };
-var getLastCommitTime = function (modulePath) {
-    // console.log(`git log -1 --format=%ci -- ${modulePath}`);
+var getLastCommitTime = function (packagePath) {
+    // console.log(`git log -1 --format=%ci -- ${packagePath}`);
     // process.exit();
-    return execPromise("git log -1 --format=%ci -- ".concat(modulePath)).then(function (result) {
+    return execPromise("git log -1 --format=%ci -- ".concat(packagePath))
+        .then(function (result) {
         var lastCommit = new Date(result);
-        // console.log(modulePath,result,lastCommit);
+        // console.log(packagePath,result,lastCommit);
         return lastCommit;
+    })["catch"](function (_a) {
+        var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+        debugInfo(chalk.red('Git error: ') + error.message.toString());
+        return null;
     });
 };
 var getLastModifiedFile = function (filePath, config) {
@@ -1092,60 +1148,90 @@ var getLastModifiedFile = function (filePath, config) {
 var publishUpdated = function (test) {
     var _this = this;
     if (test === void 0) { test = false; }
-    var modules = getLocalLincdModules();
+    var packages = getLocalLincdModules();
     var browserCoreBuilt = false;
     var p = Promise.resolve('');
-    modules.forEach(function (module) {
+    var packagesLeft = packages.length;
+    console.log('Checking which packages need to be published by comparing last published date with last git commit');
+    packages.forEach(function (pckg) {
         p = p.then(function (previousResult) {
-            log('# Checking module ' + module.moduleName);
-            // log('# Requesting ' + 'yarn info '+module.packageName+' --json');
-            // return execPromise('yarn info '+module.packageName+' --json').then((output:string) => {
+            progressUpdate(packagesLeft-- + ' packages left. Now checking ' + pckg.packageName);
+            debugInfo('# Checking package ' + pckg.packageName);
+            // log('# Requesting ' + 'yarn info '+pkg.packageName+' --json');
+            // return execPromise('yarn info '+pkg.packageName+' --json').then((output:string) => {
             // console.log("Will be requesting npm view from this current working directory:\n"+process.cwd());
-            // return execPromise('npm view '+module.packageName+' --json').then((output:string) => {
-            return execPromise('yarn info ' + module.packageName + ' --json')
+            // return execPromise('npm view '+pkg.packageName+' --json').then((output:string) => {
+            var shouldPublish;
+            var pack = (0, utils_1.getPackageJSON)(pckg.path);
+            var version = getNextVersion(pack.version);
+            if (pack.private) {
+                shouldPublish = false;
+                debugInfo(chalk.blue('--> is private, skipping'));
+                return previousResult + ' ' + chalk.gray(pckg.packageName + ' is private\n');
+            }
+            return execPromise('yarn info ' + pckg.packageName + ' --json')
                 .then(function (output) { return __awaiter(_this, void 0, void 0, function () {
-                var info, lastPublish, lastPublishDate, _a, lastModifiedTime, lastModifiedName, lastModified, lastCommit, res, browserModule;
-                return __generator(this, function (_b) {
-                    switch (_b.label) {
+                var info, lastPublish, lastPublishDate, lastCommit, res, browserModule;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
                         case 0:
                             try {
                                 if (output == '') {
-                                    // console.warn("No response (empty) from `yarn info`");
-                                    throw new Error('Empty response from `npm view`');
-                                    return [2 /*return*/];
+                                    debugInfo('No response (empty) from `yarn info`. This package was probably not published before');
+                                    // throw new Error('Empty response from `yarn info`. This pkg was probably not published before');
+                                    // return;
+                                    shouldPublish = true;
+                                    //don't patch the version number (default, see above), use the current version
+                                    version = pack.version;
+                                }
+                                else {
+                                    info = JSON.parse(output);
                                 }
-                                info = JSON.parse(output);
-                                // var stats = fs.statSync(path.join(moduleDirectory));
-                                // var files = fs.readdirSync(path.join(moduleDirectory,'src'));
+                                // var stats = fs.statSync(path.join(packageDirectory));
+                                // var files = fs.readdirSync(path.join(packageDirectory,'src'));
                             }
                             catch (err) {
-                                chalk.red(module.moduleName + ' failed: ' + err.message + '\n');
+                                chalk.red(pckg.packageName + ' failed: ' + err.message + '\n');
                                 console.warn('Returned JSON from npm: ' + output);
-                                return [2 /*return*/, previousResult + ' ' + chalk.red(module.moduleName + ' failed: ' + err.message + '\n')];
+                                return [2 /*return*/, previousResult + ' ' + chalk.red(pckg.packageName + ' failed: ' + err.message + '\n')];
                             }
+                            if (!info) return [3 /*break*/, 2];
                             lastPublish = info.data.time[info.data.version];
                             lastPublishDate = new Date(lastPublish);
-                            _a = getLastModifiedSourceTime(module.path), lastModifiedTime = _a.lastModifiedTime, lastModifiedName = _a.lastModifiedName, lastModified = _a.lastModified;
-                            return [4 /*yield*/, getLastCommitTime(module.path)];
+                            return [4 /*yield*/, getLastCommitTime(pckg.path)];
                         case 1:
-                            lastCommit = _b.sent();
-                            console.log(lastPublishDate.toDateString() + ' ' + lastPublishDate.toTimeString() + ' published ' + info.data.version);
-                            console.log(lastCommit.toDateString() + ' ' + new Date(lastCommit).toTimeString() + ' source last committed');
-                            // console.log(lastModified.toDateString() + ' ' + new Date(lastModified).toTimeString() + ' source ' + lastModifiedName + ' last edited');
-                            //NOTE: removed lastModified, because switching branches will say that the file was modified and cause everything to publish
-                            //SO: now you NEED TO commit before it picks up that you should publish
-                            //|| lastPublishDate.getTime() < lastModified.getTime()
-                            if (lastPublishDate.getTime() < lastCommit.getTime()) {
-                                res = executeSingleBuild(module, previousResult, test, info);
-                                if (module.moduleName == 'browser-core') {
+                            lastCommit = _a.sent();
+                            if (!lastCommit) {
+                                shouldPublish = false;
+                                debugInfo('Could not determine last git commit');
+                                return [2 /*return*/, previousResult + ' ' + chalk.red(pckg.packageName + ' - could not determine last commit\n')];
+                            }
+                            else {
+                                //NOTE: removed lastModified, because switching branches will say that the file was modified and cause everything to publish
+                                //SO: now you NEED TO commit before it picks up that you should publish
+                                shouldPublish = lastPublishDate.getTime() < lastCommit.getTime();
+                                if (shouldPublish) {
+                                    debugInfo(lastPublishDate.toDateString() +
+                                        ' ' +
+                                        lastPublishDate.toTimeString() +
+                                        ' published ' +
+                                        info.data.version);
+                                    debugInfo(lastCommit.toDateString() + ' ' + new Date(lastCommit).toTimeString() + ' source last committed');
+                                }
+                            }
+                            _a.label = 2;
+                        case 2:
+                            if (shouldPublish) {
+                                res = publishPackage(pckg, previousResult, test, info, version);
+                                if (pckg.packageName == 'browser-core') {
                                     browserCoreBuilt = true;
                                 }
                                 //when publishing core, also make sure to publish browser-core
-                                if (module.moduleName == 'core' && !browserCoreBuilt) {
-                                    browserModule = modules.find(function (m) { return m.moduleName == 'browser-core'; });
+                                if (pckg.packageName == 'core' && !browserCoreBuilt) {
+                                    browserModule = packages.find(function (m) { return m.packageName == 'browser-core'; });
                                     return [2 /*return*/, Promise.resolve(res).then(function (previousResult) {
-                                            log('# Automatically also publishing module browser-core');
-                                            return executeSingleBuild(browserModule, previousResult, test);
+                                            log('# Automatically also publishing package browser-core');
+                                            return publishPackage(browserModule, previousResult, test);
                                         })];
                                 }
                                 return [2 /*return*/, res];
@@ -1153,156 +1239,208 @@ var publishUpdated = function (test) {
                             return [2 /*return*/, previousResult];
                     }
                 });
-            }); })["catch"](function (err) {
-                console.log(err);
-                return previousResult + ' ' + chalk.red(module.moduleName + ' failed\n');
+            }); })["catch"](function (_a) {
+                var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+                console.log(error.message);
+                return previousResult + ' ' + chalk.red(pckg.packageName + ' failed\n');
             });
         });
     });
     return p.then(function (messages) {
         if (messages == '') {
-            console.log('All published modules are already up-to-date.');
+            console.log('All published packages are already up-to-date.');
         }
         else {
             console.log('Summary: \n' + messages);
         }
     });
 };
-var executeSingleBuild = function (module, previousResult, test, info) {
-    var nextVersion = info ? getNextVersion(info.data.version) : '';
-    console.log(chalk.blue('--> ' + (test ? 'should publish' : 'publishing') + ' ' + module.moduleName + ' ' + nextVersion));
+var publishPackage = function (pkg, previousResult, test, info, publishVersion) {
+    if (!publishVersion) {
+        publishVersion = info ? getNextVersion(info.data.version) : '';
+    }
+    if (test) {
+        debugInfo('should publish ' + pkg.packageName + ' ' + publishVersion);
+    }
+    else {
+        console.log(chalk.blue('publishing ' + pkg.packageName + ' ' + publishVersion));
+    }
     if (!test) {
-        return execPromise('cd ' + module.path + ' && yarn lincd register', true)
+        return execPromise("cd ".concat(pkg.path, " && yarn publish").concat(publishVersion ? ' --new-version ' + publishVersion : ''), true, false, {}, true)
             .then(function (res) {
             if (res.indexOf('Aborted due to warnings') !== -1 ||
                 res.indexOf('Could not publish') !== -1 ||
                 res.indexOf("Couldn't publish") !== -1) {
                 console.log(res);
-                return previousResult + ' ' + chalk.red(module.moduleName + ' failed\n');
+                return previousResult + ' ' + chalk.red(pkg.packageName + ' failed\n');
             }
-            console.log(chalk.green('Successfully published ' + nextVersion));
-            return previousResult + ' ' + chalk.green(module.moduleName + ' published ' + nextVersion + '\n');
-        })["catch"](function (err) {
-            console.log(chalk.red('Failed to publish: ' + err));
-            return chalk.red('Failed to publish: ' + err);
+            console.log(chalk.green('Successfully published ' + pkg.path + ' ' + publishVersion));
+            return previousResult + ' ' + chalk.green(pkg.packageName + ' published ' + publishVersion + '\n');
+        })["catch"](function (_a) {
+            var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+            console.log(chalk.red('Failed to publish: ' + error.message));
+            return previousResult + ' ' + chalk.red(pkg.packageName + ' failed to publish\n');
         });
     }
     else {
         //when testing what needs to be published
-        return previousResult + ' ' + chalk.blue(module.moduleName + ' should publish\n');
+        return previousResult + ' ' + chalk.blue(pkg.packageName + ' should publish\n');
     }
 };
 var buildUpdated = function (back, target, target2, test) {
     if (test === void 0) { test = false; }
-    // back = back || 1;
-    // return execPromise(`git log -${back} --format=%ci`).then((result) => {
-    // let now = new Date();
-    var previousResult = '';
-    log((test ? 'Checking which modules' : 'Building all modules that') + ' have been changed since their last built ');
-    var modules = getLocalLincdModules();
-    //TODO: sort all these modules in the order of their dependencies.
-    // To do so, see build-all command and put some of the functionality (like getting modules that depend on a module) in reusable functions
-    var p = Promise.resolve('');
-    modules.forEach(function (module) {
-        var moduleName = module.moduleName;
-        p = p
-            .then(function (previousResult) {
-            var lastModifiedSource = getLastModifiedSourceTime(module.path);
-            var lastModifiedBundle = getLastBuildTime(module.path);
-            // console.log(module.path,lastModifiedSource.lastModifiedTime,lastModifiedBundle.lastModifiedTime);
-            // console.log(module.path,new Date(lastModifiedSource.lastModified).toString(),new Date(lastModifiedBundle.lastModified).toString());
-            console.log('# Checking module ' + moduleName);
-            if (lastModifiedSource.lastModifiedTime > lastModifiedBundle.lastModifiedTime) {
-                //TODO: when building a module, also rebuild all modules that depend on this module.. and iteratively build modules that depend on those modules..
-                // log(moduleName+' modified since last commit on '+now.toString());
-                console.log(chalk.cyan('Last modified source: ' +
-                    lastModifiedSource.lastModifiedName +
-                    ' on ' +
-                    lastModifiedSource.lastModified.toString()));
-                console.log(chalk.cyan('Last build: ' +
-                    (lastModifiedBundle && typeof lastModifiedBundle.lastModified !== 'undefined'
-                        ? lastModifiedBundle.lastModified.toString()
-                        : 'never')));
-                log('--> ' + (test ? 'need to build ' : 'building ') + moduleName);
-                if (!test) {
-                    return execPromise('cd ' + module.path + ' && yarn build' + (target ? ' ' + target : '') + (target2 ? ' ' + target2 : '')).then(function (res) {
-                        if (res.indexOf('Aborted due to warnings') !== -1 || res.indexOf('Fatal error') !== -1) {
-                            console.log(res);
-                            return previousResult + ' ' + chalk.red(moduleName + ' failed\n');
+    return __awaiter(this, void 0, void 0, function () {
+        var previousResult, packages, jsonldPkgUpdated, cliPkgUpdated, rebuildAllModules, packagesLeft, p;
+        var _this = this;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    previousResult = '';
+                    log(test ? 'Checking which packages need to be rebuild' : 'Building updated packages');
+                    packages = getLocalLincdPackageMap();
+                    jsonldPkgUpdated = needsRebuilding(packages.get('lincd-jsonld'));
+                    cliPkgUpdated = needsRebuilding(packages.get('lincd-cli'));
+                    if (!(jsonldPkgUpdated || cliPkgUpdated)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, execPromise('yarn build-core', false, false, {}, true)];
+                case 1:
+                    _a.sent();
+                    _a.label = 2;
+                case 2:
+                    rebuildAllModules = false;
+                    if (cliPkgUpdated) {
+                        rebuildAllModules = true;
+                        log(chalk.magenta('Rebuilding all packages because the build tools (lincd-cli) got updated'));
+                    }
+                    packagesLeft = packages.size;
+                    runOnPackagesGroupedByDependencies(packages, function (packageGroup, dependencies) {
+                        // console.log('Now checking: ' + chalk.blue(packageGroup.map((i) => i.packageName)));
+                        // console.log((packagesLeft) + " packages left.");
+                        packagesLeft = packagesLeft - packageGroup.length;
+                        return function (pkg) { return __awaiter(_this, void 0, void 0, function () {
+                            var needRebuild;
+                            return __generator(this, function (_a) {
+                                debugInfo('# Checking package ' + pkg.packageName);
+                                needRebuild = needsRebuilding(pkg, true);
+                                if (pkg.packageName === 'lincd-jsonld' && jsonldPkgUpdated) {
+                                    needRebuild = true;
+                                }
+                                // console.log(pkg.path,lastModifiedSource.lastModifiedTime,lastModifiedBundle.lastModifiedTime);
+                                // console.log(pkg.path,new Date(lastModifiedSource.lastModified).toString(),new Date(lastModifiedBundle.lastModified).toString());
+                                if (needRebuild || rebuildAllModules) {
+                                    //TODO: when building a pkg, also rebuild all packages that depend on this package.. and iteratively build packages that depend on those packages..
+                                    // log(packageName+' modified since last commit on '+now.toString());
+                                    if (test) {
+                                        debugInfo('Need to build ' + pkg.packageName);
+                                        return [2 /*return*/, chalk.blue(pkg.packageName + ' should be build')];
+                                    }
+                                    log('Building ' + pkg.packageName);
+                                    return [2 /*return*/, execPromise('cd ' + pkg.path + ' && yarn build' + (target ? ' ' + target : '') + (target2 ? ' ' + target2 : ''))
+                                            .then(function (res) {
+                                            debugInfo(chalk.green(pkg.packageName + ' successfully built'));
+                                            return chalk.green(pkg.packageName + ' built');
+                                        })["catch"](function (_a) {
+                                            var error = _a.error, stdout = _a.stdout, stderr = _a.stderr;
+                                            warn('Failed to build ' + pkg.packageName);
+                                            console.log(stdout);
+                                            var dependentModules = getDependentPackages(dependencies, pkg);
+                                            if (dependentModules.length > 0) {
+                                                // printBuildResults(failedModules, done);
+                                                warn(chalk.red(pkg.packageName + ' build failed'));
+                                                warn('Stopping build-updated process because ' +
+                                                    dependentModules.length +
+                                                    ' other packages depend on this package.\n'); //"+dependentModules.map(d => d.packageName).join(", ")));
+                                                process.exit(1);
+                                            }
+                                        })];
+                                }
+                                return [2 /*return*/];
+                            });
+                        }); };
+                    }, function (results) {
+                        if (results.length) {
+                            log('Summary:');
+                            log(results.join('\n'));
+                        }
+                        else {
+                            log(chalk.green('Nothing to rebuild'));
                         }
-                        console.log(chalk.green(moduleName + ' bundles successfully built'));
-                        return previousResult + ' ' + chalk.green(moduleName + ' built\n');
                     });
-                }
-                return previousResult + ' ' + chalk.blue(moduleName + ' should be build\n');
+                    return [2 /*return*/];
             }
-            return previousResult;
-        })["catch"](function (err) {
-            console.log(err);
-            return previousResult + ' ' + chalk.red(moduleName + ' failed\n');
         });
     });
-    return p.then(function (messages) {
-        if (messages == '') {
-            console.log(chalk.green('Nothing to rebuild.'));
-        }
-        else {
-            console.log('Summary: \n' + messages);
-        }
-    });
-    // });
+};
+var needsRebuilding = function (pkg, logDetailsIfTrue) {
+    if (logDetailsIfTrue === void 0) { logDetailsIfTrue = false; }
+    var lastModifiedSource = getLastModifiedSourceTime(pkg.path);
+    var lastModifiedBundle = getLastBuildTime(pkg.path);
+    var result = lastModifiedSource.lastModifiedTime > lastModifiedBundle.lastModifiedTime;
+    if (logDetailsIfTrue) {
+        debugInfo(chalk.cyan('Last modified source: ' +
+            lastModifiedSource.lastModifiedName +
+            ' on ' +
+            lastModifiedSource.lastModified.toString()));
+        debugInfo(chalk.cyan('Last build: ' +
+            (lastModifiedBundle && typeof lastModifiedBundle.lastModified !== 'undefined'
+                ? lastModifiedBundle.lastModified.toString()
+                : 'never')));
+    }
+    return result;
 };
 var printBuildResults = function (failed, done) {
-    log('Build results: ' +
-        chalk.green(__spreadArray([], __read(done), false).map(function (m) { return m.moduleName; }).join(', ')) +
-        (failed.length > 0 ? ', ' + chalk.red(failed.join(', ')) : '') +
-        '\n');
+    log('Successfully built: ' + chalk.green(__spreadArray([], __read(done), false).map(function (m) { return m.packageName; }).join(', ')) + '\n');
+    if (failed.length > 0) {
+        warn('Failed to build: ' + chalk.red(failed.join(', ')) + '\n');
+    }
 };
-var executeCommandForEachModule = function (modules, command, filterMethod, filterValue) {
-    //if a specific set of modules is given
+var executeCommandForEachPackage = function (packages, command, filterMethod, filterValue) {
+    //if a specific set of packages is given
     if (filterMethod == 'exclude') {
-        //filter modules, so that we only execute on the modules as provided in the command
+        //filter packages, so that we only execute on the packages as provided in the command
         log('Excluding ' + filterValue);
         filterValue = filterValue.split(',');
-        modules = modules.filter(function (module) { return filterValue.indexOf(module.moduleName) === -1; });
+        packages = packages.filter(function (pkg) { return filterValue.indexOf(pkg.packageName) === -1; });
     }
     var startFrom;
     //by default start executing, unless 'from' is given
     var executing = true;
-    //option to start from a specific module in the stack
+    //option to start from a specific pkg in the stack
     if (filterMethod == 'from') {
         startFrom = filterValue;
         if (startFrom) {
             console.log(chalk.blue('Will skip ahead to ' + startFrom));
         }
         var seen_1 = false;
-        modules = modules.filter(function (module) {
-            if (!seen_1 && (module.moduleName == startFrom || module.packageName == startFrom)) {
+        packages = packages.filter(function (pkg) {
+            if (!seen_1 && (pkg.packageName == startFrom || pkg.packageName == startFrom)) {
                 seen_1 = true;
             }
             return seen_1;
         });
     }
-    log("Executing '" + chalk.blueBright(command) + "' on modules " + chalk.magenta(modules.map(function (m) { return m.moduleName; }).join(', ')));
+    log("Executing '" +
+        chalk.blueBright(command) +
+        "' on packages " +
+        chalk.magenta(packages.map(function (m) { return m.packageName; }).join(', ')));
     var p = Promise.resolve(true);
-    modules.forEach(function (module) {
+    packages.forEach(function (pkg) {
         p = p.then(function () {
-            log('# Package ' + chalk.magenta(module.moduleName));
-            return execp('cd ' + module.path + ' && ' + command);
+            log('# Package ' + chalk.magenta(pkg.packageName));
+            return execp('cd ' + pkg.path + ' && ' + command);
         });
     });
     return p;
 };
-var executeCommandForModule = function (moduleName, command) {
-    var moduleDetails = getLincdModules().find(function (modDetails) {
-        return modDetails.packageName.indexOf(moduleName) !== -1 || modDetails.moduleName.indexOf(moduleName) !== -1;
+var executeCommandForPackage = function (packageName, command) {
+    var packageDetails = getLincdPackages().find(function (modDetails) {
+        return modDetails.packageName.indexOf(packageName) !== -1 || modDetails.packageName.indexOf(packageName) !== -1;
     });
-    if (moduleDetails) {
-        log("Executing 'cd " + moduleDetails.path + ' && yarn lincd' + (command ? ' ' + command : '') + "'");
-        return execp('cd ' + moduleDetails.path + ' && yarn lincd' + (command ? ' ' + command : ''));
+    if (packageDetails) {
+        log("Executing 'cd " + packageDetails.path + ' && yarn lincd' + (command ? ' ' + command : '') + "'");
+        return execp('cd ' + packageDetails.path + ' && yarn lincd' + (command ? ' ' + command : ''));
     }
     else {
-        warn("Could not find a module who's name (partially) matched " + chalk.cyan(moduleName));
+        warn("Could not find a pkg who's name (partially) matched " + chalk.cyan(packageName));
     }
 };
 program.parse(process.argv);