lincd-cli 0.1.0

package/cli.js

@@ -0,0 +1,1238 @@
+#!/usr/bin/env node
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+exports.__esModule = true;
+var lib_1 = require("lincd/lib");
+var JSONLDWriter_1 = require("lincd-jsonld/lib/JSONLDWriter");
+var program = require('commander');
+var exec = require('child_process').exec;
+var chalk = require('chalk');
+var fs = require('fs-extra');
+var path = require('path');
+var glob = require('glob');
+var variables = {};
+function log() {
+    var messages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        messages[_i] = arguments[_i];
+    }
+    messages.forEach(function (message) {
+        console.log(chalk.cyan(message));
+    });
+}
+function warn() {
+    var messages = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        messages[_i] = arguments[_i];
+    }
+    messages.forEach(function (message) {
+        console.log(message);
+        // console.log(chalk.red(message));
+    });
+}
+function checkModulePath(modulePath, res) {
+    var packagePath = path.join(modulePath, 'package.json');
+    if (fs.existsSync(packagePath)) {
+        var pack = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        if (pack && pack.lincd === true) {
+            res.push({
+                path: modulePath,
+                moduleName: pack.name,
+                packageName: pack.name
+            });
+        }
+    }
+}
+/**
+ * Returns a map of the modules that this repository manages (so no modules found through the workspaces who's path contains ../ )
+ * @param rootPath
+ */
+function getLocalLincdModuleMap(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);
+        }
+    });
+    return map;
+}
+function getLocalLincdModules(rootPath) {
+    if (rootPath === void 0) { rootPath = './'; }
+    return getLincdModules(rootPath).filter(function (module) {
+        return module.path.indexOf('..\\') === -1;
+    });
+}
+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
+    var pack = getPackageJSON();
+    var res = [];
+    if (!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?
+    pack.workspaces.forEach(function (workspace) {
+        var workspacePath = path.join(rootPath, workspace.replace('/*', ''));
+        if (workspace.indexOf('/*') !== -1) {
+            // console.log(workspacePath);
+            if (fs.existsSync(workspacePath)) {
+                var folders = fs.readdirSync(workspacePath);
+                folders.forEach(function (folder) {
+                    if (folder !== './' && folder !== '../') {
+                        checkModulePath(path.join(workspacePath, folder), res);
+                    }
+                });
+            }
+        }
+        else {
+            checkModulePath(workspacePath, res);
+        }
+    });
+    // console.log(res);
+    return res;
+}
+function setVariable(name, replacement) {
+    //prepare name for regexp
+    name = name.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    variables[name] = replacement;
+}
+function execp(cmd, log, allowError, options) {
+    if (log === void 0) { log = false; }
+    if (allowError === void 0) { allowError = false; }
+    if (options === void 0) { options = {}; }
+    // opts || (opts = {});
+    if (log)
+        console.log(chalk.cyan(cmd));
+    return new Promise(function (resolve, reject) {
+        var child = exec(cmd, options);
+        child.stdout.pipe(process.stdout);
+        child.stderr.pipe(process.stderr);
+        // process.stdin.pipe(child.stdin);
+        child.on('close', function (code) {
+            if (code === 0) {
+                resolve(null);
+            }
+            else {
+                reject();
+            }
+            // console.log('killing child');
+            // child.kill('SIGHUP');
+            // resolve(code);
+        });
+        // child.on('data', function (result) {
+        // 	// if (log)
+        // 	// {
+        // 	// 	console.log(result);
+        // 	// }
+        // 	resolve(result);
+        // 	console.log('resolve data');
+        //
+        // });
+        child.on('error', function (err) {
+            if (!allowError) {
+                // console.log('reject err');
+                reject(err);
+                return;
+            }
+            else if (log) {
+                console.warn(err);
+            }
+            // console.log('resolve err');
+            resolve(null);
+        });
+        child.on('exit', function (code, signal) {
+            if (code !== 0) {
+                reject('Child process exited with error code ' + code);
+                return;
+            }
+            // console.log('resolve exit');
+            resolve(null);
+        });
+    });
+}
+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; }
+    return new Promise(function (resolve, reject) {
+        if (log)
+            console.log(chalk.cyan(command));
+        exec(command, options, function (error, stdout, stderr) {
+            if (error) {
+                if (!allowError) {
+                    reject(error.message);
+                    return;
+                }
+                else if (log) {
+                    console.warn(error);
+                }
+            }
+            var result = stdout.trim();
+            if (log) {
+                // console.log(chalk"RESOLVING "+command);
+                console.log(result);
+                // console.log('ERRORS:'+(result.indexOf('Aborted due to warnings') !== -1));
+                // console.log('stderr:'+stderr);
+            }
+            resolve(result);
+        });
+    });
+}
+var updateFile = function (filePath) { return __awaiter(void 0, void 0, void 0, function () {
+    var fileContent, newContent;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fs.readFile(filePath, 'utf8')];
+            case 1:
+                fileContent = _a.sent();
+                newContent = replaceCurlyVariables(fileContent);
+                return [2 /*return*/, fs.writeFile(filePath, newContent)];
+        }
+    });
+}); };
+var replaceCurlyVariables = function (string) {
+    // var reg = new RegExp('\\$\\{'+key+'\\}','g');
+    for (var key in variables) {
+        string = string.replace(new RegExp('\\$\\{' + key + '\\}', 'g'), variables[key]);
+    }
+    return string;
+};
+var capitalize = function (str) {
+    return str.charAt(0).toUpperCase() + str.toLowerCase().slice(1);
+};
+var camelCase = function (str) {
+    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);
+};
+// program.command('init [name] [uribase]').action((name, uriBase) => {
+// 	return initModule(name, uriBase);
+// });
+/*const initModule = (
+    name,
+    uriBase,
+    basePath = process.cwd(),
+    defaultModule = false,
+) => {
+    let pack;
+    if (!fs.existsSync(path.join(basePath, 'package.json'))) {
+        if (name) {
+            pack = require('./defaults/package.json');
+            pack.name = name;
+            fs.writeFileSync(
+                path.join(basePath, 'package.json'),
+                JSON.stringify(pack, null, 2),
+            );
+        } else {
+            log(
+                'either provide a name as argument, or first run `npm init` and then run lincd init again',
+            );
+            process.exit();
+        }
+    } else {
+        pack = require(path.join(basePath, 'package.json'));
+    }
+    if (!uriBase) {
+        uriBase = '[INSERT_URI_BASE]';
+    }
+    var moduleName = pack.name;
+
+    let camelCaseModuleName = camelCase(moduleName); //some-module --> someModule
+    let underscoreModuleName = moduleName.replace(/[-\s]+/g, '_');
+
+    setVariable('uri_base', uriBase);
+    //longer similar variables names should come before the shorter ones
+    setVariable('camel_module_name', camelCaseModuleName);
+    setVariable('underscore_module_name', underscoreModuleName);
+    setVariable('module_name', moduleName);
+    setVariable('camel_ontology_name', camelCaseModuleName);
+    setVariable('underscore_ontology_name', underscoreModuleName);
+    setVariable('ontology_name', moduleName);
+
+    // log('setting up files for module ' + moduleName+ ' from '+process.cwd());
+    // log('remember to add this module to the package.json main workspace')
+
+    log('Creating new module at ' + basePath);
+
+    return new Promise<void>((resolve, reject) => {
+        if (!fs.existsSync(path.join(basePath, 'tsconfig.json'))) {
+            var tsConfigEs6Default = fs.readFileSync(
+                path.join(__dirname, 'defaults', 'tsconfig.json'),
+            );
+            fs.writeFileSync(
+                path.join(basePath, 'tsconfig.json'),
+                tsConfigEs6Default,
+            );
+        }
+        if (!fs.existsSync(path.join(basePath, 'tsconfig-es5.json'))) {
+            var tsConfigEs5Default = fs.readFileSync(
+                path.join(__dirname, 'defaults', 'tsconfig-es5.json'),
+            );
+            fs.writeFileSync(
+                path.join(basePath, 'tsconfig-es5.json'),
+                tsConfigEs5Default,
+            );
+        }
+        if (!fs.existsSync(path.join(basePath, '.gitignore'))) {
+            var gitIgnore = fs.readFileSync(
+                path.join(__dirname, 'defaults', 'gitignorefile'),
+                {encoding: 'utf-8'},
+            );
+            fs.writeFileSync(path.join(basePath, '.gitignore'), gitIgnore);
+        }
+        if (!fs.existsSync(path.join(basePath, '.npmignore'))) {
+            var npmIgnore = fs.readFileSync(
+                path.join(__dirname, 'defaults', '.npmignore'),
+                {encoding: 'utf-8'},
+            );
+            fs.writeFileSync(path.join(basePath, '.npmignore'), npmIgnore);
+        }
+        if (!fs.existsSync(path.join(basePath, 'Gruntfile.js'))) {
+            var gruntFile = replaceCurlyVariables(
+                fs.readFileSync(path.join(__dirname, 'defaults', 'Gruntfile.js'), {
+                    encoding: 'utf-8',
+                }),
+            );
+            fs.writeFileSync(path.join(basePath, 'Gruntfile.js'), gruntFile);
+        }
+
+        if (!fs.existsSync(path.join(basePath, 'src'))) {
+            fs.mkdirSync(path.join(basePath, 'src'));
+            fs.mkdirSync(path.join(basePath, 'src', 'ontologies'));
+            fs.mkdirSync(path.join(basePath, 'src', 'shapes'));
+            fs.mkdirSync(path.join(basePath, 'src', 'views'));
+            fs.mkdirSync(path.join(basePath, 'data'));
+            fs.mkdirSync(path.join(basePath, 'data', 'ontologies'));
+            fs.writeFileSync(
+                path.join(basePath, 'src', 'index.ts'),
+                replaceCurlyVariables(
+                    fs.readFileSync(
+                        defaultModule
+                            ? path.join(__dirname, 'defaults', 'defaultModule', 'index.ts')
+                            : path.join(__dirname, 'defaults', 'index.ts'),
+                        {encoding: 'utf-8'},
+                    ),
+                ),
+            );
+
+            fs.writeFileSync(
+                path.join(basePath, 'src', 'ontologies', moduleName + '.ts'),
+                replaceCurlyVariables(
+                    fs.readFileSync(
+                        defaultModule
+                            ? path.join(__dirname, 'defaults', 'defaultModule', 'ontology.ts')
+                            : path.join(__dirname, 'defaults', 'ontology.ts'),
+                        {encoding: 'utf-8'},
+                    ),
+                ),
+            );
+        }
+
+        if (defaultModule) {
+            if (!fs.existsSync(path.join(basePath, 'data', 'data.json'))) {
+                var moduleData = replaceCurlyVariables(
+                    fs.readFileSync(
+                        path.join(__dirname, 'defaults', 'defaultModule', 'data.json'),
+                        {encoding: 'utf-8'},
+                    ),
+                );
+                fs.writeFileSync(path.join(basePath, 'data', 'data.json'), moduleData);
+            }
+            if (
+                !fs.existsSync(
+                    path.join(
+                        basePath,
+                        'data',
+                        'ontologies',
+                        camelCaseModuleName + '.json',
+                    ),
+                )
+            ) {
+                let ontologyData = replaceCurlyVariables(
+                    fs.readFileSync(
+                        path.join(
+                            __dirname,
+                            'defaults',
+                            'defaultModule',
+                            'defaultOntology.json',
+                        ),
+                        {encoding: 'utf-8'},
+                    ),
+                );
+                fs.writeFileSync(
+                    path.join(
+                        basePath,
+                        'data',
+                        'ontologies',
+                        camelCaseModuleName + '.json',
+                    ),
+                    ontologyData,
+                );
+            }
+            let indexView = replaceCurlyVariables(
+                fs.readFileSync(
+                    path.join(__dirname, 'defaults', 'defaultModule', 'Index.tsx'),
+                    {encoding: 'utf-8'},
+                ),
+            );
+            fs.writeFileSync(
+                path.join(basePath, 'src', 'views', 'Index.tsx'),
+                indexView,
+            );
+
+            let indexSCSS = fs.readFileSync(
+                path.join(__dirname, 'defaults', 'defaultModule', 'Index.scss'),
+                {encoding: 'utf-8'},
+            );
+            fs.writeFileSync(
+                path.join(basePath, 'src', 'views', 'Index.scss'),
+                indexSCSS,
+            );
+        }
+
+        resolve();
+    }).catch((e) => {
+        console.warn('Could not complete setup: ' + e);
+    });
+};*/
+var getNextVersion = function (version) {
+    var parts = version.split('.');
+    return parts[0] + '.' + parts[1] + '.' + (parseInt(parts[2]) + 1).toString();
+};
+var getNextMajorVersion = function (version) {
+    var parts = version.split('.');
+    return (parseInt(parts[0]) + 1).toString() + '.0.0';
+};
+var getNextMinorVersion = function (version) {
+    var parts = version.split('.');
+    return parts[0] + '.' + (parseInt(parts[1]) + 1).toString() + '.0';
+};
+var buildFailed = function (output) {
+    return (output.indexOf('Aborted due to warnings') !== -1 &&
+        output.indexOf('Command failed') !== -1);
+};
+program.command('shapes').action(function () { return __awaiter(void 0, void 0, void 0, function () {
+    var pack, moduleName, moduleExports, shapes, key, moduleExport, shapeContents;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!fs.existsSync(process.cwd() + '/package.json')) return [3 /*break*/, 2];
+                pack = JSON.parse(fs.readFileSync(process.cwd() + '/package.json', 'utf8'));
+                moduleName = 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');
+                moduleExports = require(process.cwd() + '/lib/index.js');
+                shapes = new Set();
+                for (key in moduleExports) {
+                    moduleExport = moduleExports[key];
+                    // console.log(key, Object.keys(moduleExports[key]));
+                    if (moduleExport.shape) {
+                        // console.log(Object.keys(moduleExport.shape));
+                        if (moduleExport.shape && moduleExport.shape instanceof lib_1.SHACL_Shape) {
+                            shapes.add(moduleExport.shape);
+                        }
+                    }
+                }
+                console.log(Object.keys(JSONLDWriter_1.JSONLDWriter).join(","));
+                return [4 /*yield*/, JSONLDWriter_1.JSONLDWriter.stringify(shapes)];
+            case 1:
+                shapeContents = _a.sent();
+                // console.log(key);
+                // let shapeContents = JSON.stringify(json);
+                // console.log(JSON.stringify(json));
+                return [2 /*return*/, fs.writeFile(path.join('dist', 'shapes.json'), shapeContents)];
+            case 2:
+                console.warn('Not a project');
+                _a.label = 3;
+            case 3: return [2 /*return*/];
+        }
+    });
+}); });
+program.command('publish [version]').action(function (newVersion) {
+    if (fs.existsSync(process.cwd() + '/package.json')) {
+        var pack = JSON.parse(fs.readFileSync(process.cwd() + '/package.json', 'utf8'));
+        var version_1 = pack.version;
+        var moduleName_1 = pack.name;
+        if (newVersion == 'same') {
+            newVersion = version_1;
+        }
+        else if (newVersion == 'minor') {
+            newVersion = getNextMinorVersion(version_1);
+            console.log(chalk.cyan('Increasing version number for minor release: ' + newVersion));
+        }
+        else if (newVersion == 'major') {
+            newVersion = getNextMajorVersion(version_1);
+            console.log(chalk.cyan('Increasing version number for major release: ' + newVersion));
+        }
+        else if (!newVersion || newVersion == 'patch') {
+            newVersion = getNextVersion(version_1);
+            console.log(chalk.cyan('Increasing version number for patch release: ' + newVersion));
+        }
+        else {
+            newVersion = version_1;
+            console.log(chalk.cyan('using given version as is: ' + newVersion));
+        }
+        // message = "%s " + message;
+        console.log(chalk.cyan('preparing to publish ' + moduleName_1 + ' ' + newVersion));
+        //temporary test code
+        return fetch('http://localhost:3000/publish', {
+            method: 'POST',
+            headers: {
+                Accept: 'application/json, text/plain, */*',
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ package: moduleName_1 })
+        })
+            .then(function (res) { return res.text(); })
+            .then(function (text) {
+            console.log(text);
+        });
+        console.log(chalk.cyan('building production bundles'));
+        return execPromise('yarn lincd build production', false, true)
+            .then(function (output) {
+            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(function (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 ".concat(moduleName_1, " ").concat(newVersion, "\" -- ./ & git tag ").concat(moduleName_1, "@").concat(newVersion, "\""));
+        })
+            .then(function (version) {
+            console.log(chalk.cyan('Publishing ' + moduleName_1 + ' ' + newVersion));
+            // let tag = moduleName+'@'+version;
+            return execPromise('yarn publish --new-version ' + newVersion, 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(chalk.red('Failed to publish'));
+                return false;
+            }
+            else {
+                var pack = JSON.parse(fs.readFileSync(process.cwd() + '/package.json', 'utf8'));
+                version_1 = pack.version;
+                console.log(chalk.green('Published ' + version_1));
+                return true;
+            }
+        })["catch"](function (err) {
+            console.warn(chalk.red('Could not publish: ' + err));
+        });
+    }
+    else {
+        console.warn('not found: ' + process.cwd() + '/package.json');
+    }
+});
+var getPackageJSON = function (root) {
+    if (root === void 0) { root = process.cwd(); }
+    var packagePath = path.join(root, 'package.json');
+    if (fs.existsSync(packagePath)) {
+        return JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    }
+    else if (root === process.cwd()) {
+        console.warn('Could not find package.json. Make sure you run this command from the root of a lincd module or a lincd yarn workspace');
+        process.exit();
+    }
+};
+// 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];
+    }
+    // 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; }
+    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."));
+            return;
+        }
+        var nodeEnv = '';
+        if (target == 'production') {
+            if (!(target2 == 'es5' || target2 == 'es6' || typeof target2 == 'undefined')) {
+                console.warn('unknown second build target. Use es5 or es6', target2);
+                return;
+            }
+            var isWindows = /^win/.test(process.platform);
+            if (isWindows) {
+                nodeEnv = 'SET NODE_ENV=production&& ';
+            }
+            else {
+                nodeEnv = "NODE_ENV='production' ";
+            }
+        }
+        if (!target) {
+            target = 'es6';
+        }
+        log('building once: ' +
+            nodeEnv +
+            'grunt build' +
+            (target ? '-' + target : '') +
+            (target2 ? '-' + target2 : '') +
+            ' --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) {
+            process.exit(1);
+        });
+    }
+    else {
+        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');
+};
+var getLastModifiedSourceTime = function (modulePath) {
+    return getLastModifiedFile(modulePath + '/@(src|data|scss)/**/*', {
+        ignore: [modulePath + '/**/*.scss.json', modulePath + '/**/*.d.ts']
+    });
+};
+var getLastCommitTime = function (modulePath) {
+    // console.log(`git log -1 --format=%ci -- ${modulePath}`);
+    // process.exit();
+    return execPromise("git log -1 --format=%ci -- ".concat(modulePath)).then(function (result) {
+        var lastCommit = new Date(result);
+        // console.log(modulePath,result,lastCommit);
+        return lastCommit;
+    });
+};
+var getLastModifiedFile = function (filePath, config) {
+    if (config === void 0) { config = {}; }
+    var files = glob.sync(filePath, config);
+    // console.log(files.join(" - "));
+    var lastModifiedName;
+    var lastModified;
+    var lastModifiedTime = 0;
+    files.forEach(function (fileName) {
+        if (fs.lstatSync(fileName).isDirectory()) {
+            // 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) {
+            // console.log(fileName,mtime);
+            lastModifiedName = fileName;
+            lastModified = mtime;
+            lastModifiedTime = modifiedTime;
+        }
+    });
+    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; }
+    var modules = getLocalLincdModules();
+    var browserCoreBuilt = false;
+    var p = Promise.resolve('');
+    modules.forEach(function (module) {
+        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) => {
+            // 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')
+                .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) {
+                        case 0:
+                            try {
+                                if (output == '') {
+                                    // console.warn("No response (empty) from `yarn info`");
+                                    throw new Error('Empty response from `npm view`');
+                                    return [2 /*return*/];
+                                }
+                                info = JSON.parse(output);
+                                // var stats = fs.statSync(path.join(moduleDirectory));
+                                // var files = fs.readdirSync(path.join(moduleDirectory,'src'));
+                            }
+                            catch (err) {
+                                chalk.red(module.moduleName + ' failed: ' + err.message + '\n');
+                                console.warn('Returned JSON from npm: ' + output);
+                                return [2 /*return*/, (previousResult +
+                                        ' ' +
+                                        chalk.red(module.moduleName + ' failed: ' + err.message + '\n'))];
+                            }
+                            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)];
+                        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') {
+                                    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'; });
+                                    return [2 /*return*/, Promise.resolve(res).then(function (previousResult) {
+                                            log('# Automatically also publishing module browser-core');
+                                            return executeSingleBuild(browserModule, previousResult, test);
+                                        })];
+                                }
+                                return [2 /*return*/, res];
+                            }
+                            return [2 /*return*/, previousResult];
+                    }
+                });
+            }); })["catch"](function (err) {
+                console.log(err);
+                return (previousResult + ' ' + chalk.red(module.moduleName + ' failed\n'));
+            });
+        });
+    });
+    return p.then(function (messages) {
+        if (messages == '') {
+            console.log('All published modules 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));
+    if (!test) {
+        return execPromise('cd ' + module.path + ' && yarn lincd publish', 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'));
+            }
+            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);
+        });
+    }
+    else {
+        //when testing what needs to be published
+        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;
+    return execPromise("git log -".concat(back, " --format=%ci")).then(function (result) {
+        var lastCommit = new Date(result);
+        var previousResult = '';
+        log((test ? 'Checking which modules' : 'Building all modules that') +
+            ' have been changed since last commit on ' +
+            lastCommit.toString());
+        var modules = getLocalLincdModules();
+        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) {
+                    // log(moduleName+' modified since last commit on '+lastCommit.toString());
+                    console.log(chalk.cyan('Last modified source: ' +
+                        lastModifiedSource.lastModifiedName +
+                        ' on ' +
+                        lastModifiedSource.lastModified.toString()));
+                    console.log(chalk.cyan('Last build: ' + lastModifiedBundle.lastModified.toString()));
+                    log('--> ' + (test ? 'need to build ' : 'building ') + moduleName);
+                    if (!test) {
+                        return execPromise('cd ' +
+                            module.path +
+                            ' && yarn lincd 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'));
+                            }
+                            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 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);
+            }
+        });
+    });
+};
+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 = 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, 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);
+                    }
+                    stack.forEach(function (module) {
+                        p = p.then(function () {
+                            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.magenta(modulesLeft + ' modules left'));
+                                log(chalk.cyan('Building ' + module.moduleName));
+                            }
+                            modulesLeft--;
+                            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(", ")));
+                                    process.exit(1);
+                                }
+                            });
+                        });
+                        done.add(module);
+                    });
+                    //wait till stack is completed
+                    return [4 /*yield*/, p];
+                case 1:
+                    //wait till stack is completed
+                    _a.sent();
+                    //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);
+});
+var executeCommandForEachModule = function (modules, command, includedSpaces, excludedSpaces) {
+    //if a specific set of modules is given
+    if (includedSpaces) {
+        //filter modules, so that we only execute on the modules as provided in the command
+        includedSpaces = includedSpaces.split(',');
+        modules = modules.filter(function (module) { return includedSpaces.indexOf(module.moduleName) !== -1; });
+        log('Applying to included spaces');
+    }
+    //if a specific set of modules is given
+    if (excludedSpaces) {
+        //filter modules, so that we only execute on the modules as provided in the command
+        excludedSpaces = excludedSpaces.split(',');
+        modules = modules.filter(function (module) { return excludedSpaces.indexOf(module.moduleName) === -1; });
+        log('Filtering excluded spaces');
+    }
+    log("Executing '" +
+        command +
+        "' on modules " +
+        modules.map(function (m) { return m.moduleName; }).join(', '));
+    var p = Promise.resolve(true);
+    modules.forEach(function (module) {
+        p = p.then(function () {
+            log('# Module ' + module.moduleName + ' - ' + module.path);
+            return execp('cd ' + module.path + ' && ' + command);
+        });
+    });
+    return p;
+};
+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);
+    }
+    else {
+        console.warn('unknown build target. Use es5 or es6');
+    }
+});
+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('- 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 [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);