tnp-helpers 18.0.19 → 18.0.21

package/lib/base/classes/base-command-line.backend.js

@@ -0,0 +1,2235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseCommandLine = void 0;
+var tslib_1 = require("tslib");
+var index_1 = require("../../index");
+var command_line_feature_backend_1 = require("./../command-line-feature.backend");
+var tnp_core_1 = require("tnp-core");
+var tnp_config_1 = require("tnp-config");
+var tnp_config_2 = require("tnp-config");
+var tnp_core_2 = require("tnp-core");
+var gh_temp_code_1 = require("../gh-temp-code");
+var BaseCommandLine = /** @class */ (function (_super) {
+    tslib_1.__extends(BaseCommandLine, _super);
+    function BaseCommandLine() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    BaseCommandLine.prototype._ = function () {
+        index_1.Helpers.error('Please select git command');
+    };
+    //#region commands / prevent cwd is not project
+    /**
+     * TODO return argument not need for now
+     */
+    BaseCommandLine.prototype.cwdIsProject = function (options) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var requireProjectWithGitRoot, proj, useRoot;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        requireProjectWithGitRoot = (options || {}).requireProjectWithGitRoot;
+                        if (!!this.project && !requireProjectWithGitRoot) {
+                            return [2 /*return*/, true];
+                        }
+                        if (!(requireProjectWithGitRoot &&
+                            (!this.project || !this.project.git.isGitRoot))) return [3 /*break*/, 3];
+                        proj = this.ins.nearestTo(this.cwd, { findGitRoot: true });
+                        if (!proj) return [3 /*break*/, 2];
+                        index_1.Helpers.info("\n              Current folder (".concat(this.cwd, ")\n              is not a git root folder, but nearest project with\n              git root has been found in: ").concat(tnp_core_1.chalk.bold(proj.genericName), "\n\n              "));
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo('Would you like to use this project ?')];
+                    case 1:
+                        useRoot = _a.sent();
+                        if (useRoot) {
+                            this.project = proj;
+                            this.cwd = proj.location;
+                            return [2 /*return*/, true];
+                        }
+                        else {
+                            index_1.Helpers.error("[".concat(tnp_config_2.config.frameworkName, "] This is not git root project folder"), true, true);
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        index_1.Helpers.error("[".concat(tnp_config_2.config.frameworkName, "] This folder is not project folder"), false, true);
+                        _a.label = 3;
+                    case 3: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / hosts
+    BaseCommandLine.prototype.hosts = function () {
+        index_1.Helpers.run("code ".concat((0, tnp_core_2.crossPlatformPath)(tnp_config_1.HOST_FILE_PATH))).sync();
+        process.exit(0);
+    };
+    //#endregion
+    //#region commands / count commits
+    BaseCommandLine.prototype.countCommits = function () {
+        console.log(index_1.Helpers.git.countCommits(this.cwd));
+        this._exit();
+    };
+    //#endregion
+    //#region commands / remove submodules
+    BaseCommandLine.prototype.removeSubmodules = function () {
+        var e_1, _a;
+        index_1.Helpers.taskStarted('Removing submodules...');
+        try {
+            for (var _b = tslib_1.__values(index_1.Helpers.foldersFrom(this.cwd, {
+                recursive: false,
+            })), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var folderAbsPath = _c.value;
+                if (index_1.Helpers.exists((0, tnp_core_2.crossPlatformPath)([folderAbsPath, '.git']))) {
+                    try {
+                        index_1.Helpers.run("git rm --cached ".concat(tnp_core_1.path.basename(folderAbsPath))).sync();
+                    }
+                    catch (error) { }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        index_1.Helpers.taskDone('Done');
+        this._exit();
+    };
+    //#endregion
+    //#region commands / set editor
+    BaseCommandLine.prototype.setEditor = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ins.configDb.selectCodeEditor()];
+                    case 1:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / quick git update
+    /**
+     * quick git update push
+     */
+    BaseCommandLine.prototype.update = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        index_1.Helpers.info('Updating & push project...');
+                        try {
+                            this.project.git.addAndCommit("chore: ".concat(!!this.firstArg ? this.firstArg : 'update'));
+                        }
+                        catch (error) { }
+                        return [4 /*yield*/, this.project.git.pushCurrentBranch({
+                                askToRetry: true,
+                                forcePushNoQuestion: true,
+                            })];
+                    case 2:
+                        _a.sent();
+                        index_1.Helpers.info('Done');
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.deepUp = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (noExit) {
+            if (noExit === void 0) { noExit = false; }
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.deepUpdate(noExit)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.deepUpdate = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (noExit) {
+            var updateProject;
+            var _this = this;
+            if (noExit === void 0) { noExit = false; }
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        index_1.Helpers.info('Deep updating & pushing project with children...');
+                        updateProject = function (project) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var error_1, _a, _b, child, e_2_1;
+                            var e_2, _c;
+                            return tslib_1.__generator(this, function (_d) {
+                                switch (_d.label) {
+                                    case 0:
+                                        _d.trys.push([0, 2, , 3]);
+                                        return [4 /*yield*/, project.npmHelpers.bumpPatchVersion()];
+                                    case 1:
+                                        _d.sent();
+                                        return [3 /*break*/, 3];
+                                    case 2:
+                                        error_1 = _d.sent();
+                                        return [3 /*break*/, 3];
+                                    case 3:
+                                        try {
+                                            project.git.addAndCommit("chore: ".concat(!!this.firstArg ? this.args.join(' ') : 'update'));
+                                        }
+                                        catch (error) { }
+                                        return [4 /*yield*/, project.git.pushCurrentBranch({
+                                                askToRetry: true,
+                                                forcePushNoQuestion: true,
+                                            })];
+                                    case 4:
+                                        _d.sent();
+                                        if (!!project.isMonorepo) return [3 /*break*/, 12];
+                                        _d.label = 5;
+                                    case 5:
+                                        _d.trys.push([5, 10, 11, 12]);
+                                        _a = tslib_1.__values(project.children), _b = _a.next();
+                                        _d.label = 6;
+                                    case 6:
+                                        if (!!_b.done) return [3 /*break*/, 9];
+                                        child = _b.value;
+                                        if (!child.git.isGitRoot) return [3 /*break*/, 8];
+                                        return [4 /*yield*/, updateProject(child)];
+                                    case 7:
+                                        _d.sent();
+                                        _d.label = 8;
+                                    case 8:
+                                        _b = _a.next();
+                                        return [3 /*break*/, 6];
+                                    case 9: return [3 /*break*/, 12];
+                                    case 10:
+                                        e_2_1 = _d.sent();
+                                        e_2 = { error: e_2_1 };
+                                        return [3 /*break*/, 12];
+                                    case 11:
+                                        try {
+                                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                        }
+                                        finally { if (e_2) throw e_2.error; }
+                                        return [7 /*endfinally*/];
+                                    case 12: return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        return [4 /*yield*/, updateProject(this.project)];
+                    case 2:
+                        _a.sent();
+                        index_1.Helpers.info('Done');
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Push update
+     */
+    BaseCommandLine.prototype.up = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.update()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Push update
+     */
+    BaseCommandLine.prototype.pu = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.update()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / develop
+    BaseCommandLine.prototype.develop = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var founded, results, openInEditor, res;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Helpers.clearConsole();
+                        index_1.Helpers.taskStarted("getting all projects...");
+                        return [4 /*yield*/, this.ins.projectsDb.getAllProjectsFromDB()];
+                    case 1:
+                        founded = ((_a.sent()) || [])
+                            .filter(function (p) { return index_1.Helpers.exists(p.location); })
+                            .map(function (p) {
+                            var proj = _this.ins.From(p.location);
+                            // console.log(`Proj for ${p.location} `, !!proj)
+                            if (proj) {
+                                return proj;
+                                // return proj.embeddedProject ? proj.embeddedProject : proj;
+                            }
+                            // const nereset = this.ins.nearestTo(p.location);
+                            // if (nereset) {
+                            //   const embeded = nereset.linkedProjects.find(l => crossPlatformPath([nereset.location, l.relativeClonePath]) === p.location);
+                            //   if (embeded) {
+                            //     return this.ins.From([nereset.location, embeded.relativeClonePath]);
+                            //   }
+                            // }
+                        })
+                            .filter(function (p) { return !!p; });
+                        index_1.Helpers.taskDone("found ".concat(founded.length, " projects..."));
+                        index_1.Helpers.taskStarted("searching for project...");
+                        results = index_1.Helpers.uniqArray(tslib_1.__spreadArray(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(index_1.Helpers.arrays.fuzzy(this.args.join(' '), founded, function (p) { return p.name; })
+                            .results), false), tslib_1.__read(index_1.Helpers.arrays.fuzzy(this.args.join(' '), founded, function (p) { return p.basename; })
+                            .results), false), tslib_1.__read(index_1.Helpers.arrays.fuzzy(this.args.join(' '), founded, function (p) { return p.location; })
+                            .results), false), 'location');
+                        index_1.Helpers.taskDone("found ".concat(results.length, " projects..."));
+                        openInEditor = function (proj) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var editor, embededProject, porjToOpen, locaitonFolderToOpen, error_2;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        index_1.Helpers.taskStarted("Getting code editor info...");
+                                        return [4 /*yield*/, this.ins.configDb.getCodeEditor()];
+                                    case 1:
+                                        editor = _a.sent();
+                                        index_1.Helpers.taskDone("Got code editor info...");
+                                        embededProject = proj.linkedProjects.embeddedProject;
+                                        porjToOpen = embededProject || proj;
+                                        locaitonFolderToOpen = porjToOpen.location;
+                                        index_1.Helpers.info('Initing and opening project...');
+                                        _a.label = 2;
+                                    case 2:
+                                        _a.trys.push([2, 4, , 5]);
+                                        return [4 /*yield*/, (porjToOpen === null || porjToOpen === void 0 ? void 0 : porjToOpen.struct())];
+                                    case 3:
+                                        _a.sent();
+                                        return [3 /*break*/, 5];
+                                    case 4:
+                                        error_2 = _a.sent();
+                                        return [3 /*break*/, 5];
+                                    case 5:
+                                        index_1.Helpers.run("".concat(editor, " ").concat(locaitonFolderToOpen)).sync();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); };
+                        if (!(results.length === 1)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, openInEditor(tnp_core_1._.first(results))];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 3:
+                        if (!(results.length === 0)) return [3 /*break*/, 4];
+                        index_1.Helpers.error("No project found by name: \"".concat(this.args.join(' '), "\""), false, true);
+                        return [3 /*break*/, 7];
+                    case 4:
+                        index_1.Helpers.info("Opening console gui to select project...");
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.select('Select project to open', results.map(function (p) {
+                                return {
+                                    name: p.genericName,
+                                    value: p.location,
+                                };
+                            }), true)];
+                    case 5:
+                        res = _a.sent();
+                        return [4 /*yield*/, openInEditor(this.ins.From(res))];
+                    case 6:
+                        _a.sent();
+                        _a.label = 7;
+                    case 7:
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.dev = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.develop()];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / repulll
+    BaseCommandLine.prototype.repul = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.repull()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.repull = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.project.git.resetHard({ HEAD: 10 })];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.pull()];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / pull
+    BaseCommandLine.prototype.pull = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.project.git.pullProcess({
+                                setOrigin: this.params['setOrigin'],
+                            })];
+                    case 2:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / pull all
+    BaseCommandLine.prototype.pullAll = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.project.git.pullProcess({
+                                cloneChildren: true,
+                                setOrigin: this.params['setOrigin'],
+                            })];
+                    case 2:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    BaseCommandLine.prototype.pp = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var currentBranch;
+            return tslib_1.__generator(this, function (_a) {
+                currentBranch = this.project.git.currentBranchName;
+                this.project
+                    .run("git push origin ".concat(currentBranch, " && git pull origin ").concat(currentBranch))
+                    .sync();
+                console.log('Done push and pull');
+                this._exit();
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#region commands / reset
+    BaseCommandLine.prototype.__resetInfo = function (branchToReset) {
+        index_1.Helpers.info("\n\n    YOU ARE RESETING EVERYTHING TO BRANCH: ".concat(tnp_core_1.chalk.bold(branchToReset), "\n\n- curret project (").concat(this.project.name, ")\n").concat(tnp_core_1._.isArray(this.project.children) && this.project.children.length > 0
+            ? "- modules:\n".concat(this.project.children
+                .map(function (c) { return "\t".concat(c.basename, " (").concat(tnp_core_1.chalk.yellow(c.name), ")"); })
+                .join('\n'))
+            : '', "\n      "));
+    };
+    BaseCommandLine.prototype.fetch = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return tslib_1.__generator(this, function (_c) {
+                try {
+                    (_b = (_a = this.project) === null || _a === void 0 ? void 0 : _a.git) === null || _b === void 0 ? void 0 : _b.fetch();
+                }
+                catch (error) { }
+                this._exit();
+                return [2 /*return*/];
+            });
+        });
+    };
+    BaseCommandLine.prototype.reset = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var parent, branchFromLinkedProjectConfig, overrideBranchToReset, resetOnlyChildren, branches, resetProject, res;
+            var _this = this;
+            var _a, _b, _c, _d, _e;
+            return tslib_1.__generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        // Helpers.clearConsole();
+                        if (!(_f.sent())) {
+                            return [2 /*return*/];
+                        }
+                        parent = this.project.parent;
+                        branchFromLinkedProjectConfig = (_b = (_a = parent === null || parent === void 0 ? void 0 : parent.linkedProjects) === null || _a === void 0 ? void 0 : _a.linkedProjects.find(function (l) {
+                            return ((0, tnp_core_2.crossPlatformPath)([parent.location, l.relativeClonePath]) ===
+                                _this.project.location);
+                        })) === null || _b === void 0 ? void 0 : _b.deafultBranch;
+                        overrideBranchToReset = this.firstArg ||
+                            branchFromLinkedProjectConfig ||
+                            ((_c = this.project.core) === null || _c === void 0 ? void 0 : _c.branch) ||
+                            this.project.getDefaultDevelopmentBranch() ||
+                            this.project.git.currentBranchName;
+                        if ((_d = this.project.core) === null || _d === void 0 ? void 0 : _d.branch) {
+                            index_1.Helpers.info("\n\n        Core branch for project: ".concat((_e = this.project.core) === null || _e === void 0 ? void 0 : _e.branch, "\n\n        "));
+                        }
+                        resetOnlyChildren = !!this.project.linkedProjects.getLinkedProjectsConfig().resetOnlyChildren;
+                        branches = index_1.Helpers.uniqArray(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(this.__filterBranchesByPattern(overrideBranchToReset)), false), tslib_1.__read(this.__filterBranchesByPattern('')), false));
+                        if (!resetOnlyChildren) return [3 /*break*/, 2];
+                        index_1.Helpers.info("Reseting only children...for defualt branches.");
+                        return [3 /*break*/, 5];
+                    case 2:
+                        if (!(branches.length > 0)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.__selectBrach(branches, 'reset')];
+                    case 3:
+                        overrideBranchToReset = _f.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        index_1.Helpers.error("No branch found by name \"".concat(overrideBranchToReset || this.firstArg, "\""), false, true);
+                        _f.label = 5;
+                    case 5:
+                        overrideBranchToReset = overrideBranchToReset || '';
+                        this.__resetInfo(overrideBranchToReset
+                            ? overrideBranchToReset
+                            : this.project.getDefaultDevelopmentBranch());
+                        resetProject = this.project;
+                        if (!(this.project.git.isInsideGitRepo && !this.project.git.isGitRoot)) return [3 /*break*/, 7];
+                        index_1.Helpers.warn("You are not in root of git repo...", false);
+                        resetProject = this.ins.nearestTo((0, tnp_core_2.crossPlatformPath)([this.project.location, '..']), {
+                            findGitRoot: true,
+                        });
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo("Would you like to reset root repo instead (project=".concat(tnp_core_1.chalk.bold.red(resetProject.genericName), ") ?"))];
+                    case 6:
+                        if (!(_f.sent())) {
+                            index_1.Helpers.error("Aborted", false, true);
+                        }
+                        _f.label = 7;
+                    case 7: return [4 /*yield*/, index_1.Helpers.questionYesNo("Reset hard and pull current project " +
+                            "".concat(resetProject.linkedProjects.linkedProjects.length > 0 ? '(and children)' : '', " ?"))];
+                    case 8:
+                        res = _f.sent();
+                        if (!res) return [3 /*break*/, 10];
+                        return [4 /*yield*/, resetProject.resetProcess(overrideBranchToReset)];
+                    case 9:
+                        _f.sent();
+                        _f.label = 10;
+                    case 10:
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / soft
+    BaseCommandLine.prototype.soft = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        // TODO when aciton commit
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        this.project.git.resetSoftHEAD(1);
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / rebase
+    BaseCommandLine.prototype.rebase = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var currentBranch, safeReset, rebaseBranch, branches, error_3;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        currentBranch = this.project.git.currentBranchName;
+                        safeReset = 10;
+                        rebaseBranch = this.firstArg || this.project.getDefaultDevelopmentBranch();
+                        branches = this.__filterBranchesByPattern(rebaseBranch);
+                        if (!(branches.length > 0)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.__selectBrach(branches, 'reset')];
+                    case 2:
+                        rebaseBranch = _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        index_1.Helpers.error("No branch found by name \"".concat(rebaseBranch, "\""), false, true);
+                        _a.label = 4;
+                    case 4:
+                        _a.trys.push([4, 6, , 8]);
+                        this.project
+                            .run("git reset--hard && git checkout ".concat(rebaseBranch, " && git reset--hard HEAD~").concat(safeReset, " && git pull origin ").concat(rebaseBranch, " ") +
+                            "&& git checkout ".concat(currentBranch, " && git reset--soft HEAD~1 && git stash && git reset--hard HEAD~").concat(safeReset, " && git rebase ").concat(rebaseBranch, " && git stash apply"), { output: false, silence: true })
+                            .sync();
+                        return [4 /*yield*/, this.project.init()];
+                    case 5:
+                        _a.sent();
+                        index_1.Helpers.info('REBASE DONE');
+                        return [3 /*break*/, 8];
+                    case 6:
+                        error_3 = _a.sent();
+                        return [4 /*yield*/, this.project.init()];
+                    case 7:
+                        _a.sent();
+                        index_1.Helpers.warn('PLEASE MERGE YOUR CHANGES');
+                        return [3 /*break*/, 8];
+                    case 8:
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / stash
+    /**
+     * stash only staged files
+     */
+    BaseCommandLine.prototype.stash = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        index_1.Helpers.info("Stashing only staged files...");
+                        return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        this.project.git.stash({ onlyStaged: true });
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / stash all
+    /**
+     * stash all files
+     */
+    BaseCommandLine.prototype.stashAll = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        this.project.git.stageAllFiles();
+                        this.project.git.stash({ onlyStaged: false });
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push all origins
+    /**
+     * push force to all orgins
+     */
+    BaseCommandLine.prototype.pushAllForce = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.pushAll(true)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pAllForce = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushAllForce()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pAllf = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushAllForce()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pAll = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushAll()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * push to all origins
+     */
+    BaseCommandLine.prototype.pushAll = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (force) {
+            var remotes, index, _a, origin_1, url;
+            if (force === void 0) { force = false; }
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_b.sent())) {
+                            return [2 /*return*/];
+                        }
+                        remotes = this.project.git.allOrigins;
+                        index_1.Helpers.info("\n\n    Remotes for repo:\n\n".concat(remotes.map(function (r, i) { return "".concat(i + 1, ". ").concat(r.origin, " ").concat(r.url); }).join('\n'), "\n\n"));
+                        index = 0;
+                        _b.label = 2;
+                    case 2:
+                        if (!(index < remotes.length)) return [3 /*break*/, 5];
+                        _a = remotes[index], origin_1 = _a.origin, url = _a.url;
+                        index_1.Helpers.taskStarted("Pushing to ".concat(tnp_core_1.chalk.bold(origin_1), " (").concat(url, ")..."));
+                        return [4 /*yield*/, this.push({ force: force, origin: origin_1, noExit: true })];
+                    case 3:
+                        _b.sent();
+                        index_1.Helpers.taskDone("Pushed to ".concat(origin_1));
+                        _b.label = 4;
+                    case 4:
+                        index++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push force
+    BaseCommandLine.prototype.forcePush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.push({ force: true, typeofCommit: 'feature' })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pushForce = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.push({ force: true, typeofCommit: 'feature' })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / commit
+    /**
+     * Commit and push this for single repo
+     */
+    BaseCommandLine.prototype.commit = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (options) {
+            var _this = this;
+            if (options === void 0) { options = {}; }
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.project.git.meltActionCommits()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.project.git.pushProcess(tslib_1.__assign(tslib_1.__assign({}, options), { forcePushNoQuestion: options.force, args: this.args, exitCallBack: function () {
+                                    _this._exit();
+                                }, skipChildren: true, overrideCommitMessage: this.args.join(' '), setOrigin: this.params['setOrigin'], currentOrigin: this.project.git.originURL }))];
+                    case 3:
+                        _a.sent();
+                        if (options.noExit) {
+                            return [2 /*return*/];
+                        }
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push
+    BaseCommandLine.prototype._preventPushPullFromNotCorrectBranch = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _loop_1, this_1, state_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _loop_1 = function () {
+                            var devBranch, options_1, res;
+                            return tslib_1.__generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        devBranch = this_1.project.git.duringPushWarnIfProjectNotOnSpecyficDevBranch();
+                                        if (!(!!devBranch && devBranch !== this_1.project.git.currentBranchName)) return [3 /*break*/, 2];
+                                        index_1.Helpers.warn("\n\n        ".concat(this_1.project.genericName, "\n\n        You are not on ").concat(devBranch, " branch. Please switch to this branch and try again\n\n\n\n        "), false);
+                                        options_1 = {
+                                            open: { name: 'Open in vscode' },
+                                            continue: { name: 'Continue (check again)' },
+                                            continueForce: { name: 'Continue (without checking)' },
+                                            exit: { name: 'Exit process' },
+                                        };
+                                        return [4 /*yield*/, index_1.Helpers.selectChoicesAsk('What you want to do ?', Object.keys(options_1).map(function (k) {
+                                                return { name: options_1[k].name, value: k };
+                                            }))];
+                                    case 1:
+                                        res = _b.sent();
+                                        if (res === 'continue') {
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        if (res === 'exit') {
+                                            this_1._exit();
+                                        }
+                                        if (res === 'open') {
+                                            this_1.project.run('code . ').sync();
+                                            return [2 /*return*/, "continue"];
+                                        }
+                                        if (res === 'continueForce') {
+                                            return [2 /*return*/, { value: void 0 }];
+                                        }
+                                        _b.label = 2;
+                                    case 2: return [2 /*return*/, { value: void 0 }];
+                                }
+                            });
+                        };
+                        this_1 = this;
+                        _a.label = 1;
+                    case 1:
+                        if (!true) return [3 /*break*/, 3];
+                        return [5 /*yield**/, _loop_1()];
+                    case 2:
+                        state_1 = _a.sent();
+                        if (typeof state_1 === "object")
+                            return [2 /*return*/, state_1.value];
+                        return [3 /*break*/, 1];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.qPush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.quickPush()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.quickPush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.push({ skipLint: true })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.push = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (options) {
+            var _this = this;
+            if (options === void 0) { options = {}; }
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        // console.log('args', this.args);
+                        // console.log(`argsWithParams "${this.argsWithParams}"` );
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this._preventPushPullFromNotCorrectBranch()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.project.git.pushProcess(tslib_1.__assign(tslib_1.__assign({}, options), { forcePushNoQuestion: options.force, args: (options === null || options === void 0 ? void 0 : options.overrideCommitMessage)
+                                    ? ((options === null || options === void 0 ? void 0 : options.overrideCommitMessage) || '').split(' ')
+                                    : this.args, exitCallBack: function () {
+                                    _this._exit();
+                                }, setOrigin: this.params['setOrigin'], currentOrigin: this.project.git.originURL }))];
+                    case 3:
+                        _a.sent();
+                        if (options.noExit) {
+                            return [2 /*return*/];
+                        }
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / melt
+    BaseCommandLine.prototype.melt = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.meltUpdateCommits(true)];
+                    case 2:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / melt updat ecommits
+    BaseCommandLine.prototype.meltUpdateCommits = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (hideInfo) {
+            if (hideInfo === void 0) { hideInfo = false; }
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(this.project.git.meltActionCommits() > 0)) return [3 /*break*/, 2];
+                        if (!!hideInfo) return [3 /*break*/, 2];
+                        this.project.git.stageAllFiles();
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.question.yesNo('Update commits has been reset. Continue with changes ?')];
+                    case 1:
+                        if (!(_a.sent())) {
+                            this._exit();
+                        }
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push feature
+    BaseCommandLine.prototype.pf = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushFeature()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pRel = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushRelease()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pRelease = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushRelease()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pushRelease = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({
+                                typeofCommit: 'release',
+                                commitMessageRequired: true,
+                                overrideCommitMessage: "".concat(tnp_core_1._.first(this.project.releaseProcess.getReleaseWords()), " ") +
+                                    "version ".concat(this.project.npmHelpers.version),
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.mPush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltPush()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.fmPush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.forceMeltPush()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.mfPush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.forceMeltPush()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.mforcePush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.forceMeltPush()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.meltforcePush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.forceMeltPush()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.forceMeltPush = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltPush(true)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.meltPush = function () {
+        return tslib_1.__awaiter(this, arguments, void 0, function (force) {
+            if (force === void 0) { force = false; }
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({
+                                mergeUpdateCommits: true,
+                                force: force,
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pushFeature = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({ typeofCommit: 'feature', commitMessageRequired: true })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push fix
+    BaseCommandLine.prototype.pushFix = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({ typeofCommit: 'bugfix', commitMessageRequired: true })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pfix = function () {
+        this.pushFix();
+    };
+    //#endregion
+    //#region commands / push chore
+    BaseCommandLine.prototype.pushChore = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({ typeofCommit: 'chore', commitMessageRequired: true })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pc = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushChore()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push refactor
+    BaseCommandLine.prototype.pushRefactor = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({ typeofCommit: 'refactor', commitMessageRequired: true })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pushref = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushRefactor()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pref = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushRefactor()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push style
+    BaseCommandLine.prototype.pushStyle = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({ typeofCommit: 'style', commitMessageRequired: true })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pstyl = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushStyle()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pstyle = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushStyle()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push docs
+    BaseCommandLine.prototype.pushDocs = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({ typeofCommit: 'docs', commitMessageRequired: true })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pd = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushDocs()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pdocs = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushDocs()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push test
+    BaseCommandLine.prototype.pushTest = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({ typeofCommit: 'test', commitMessageRequired: true })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pTest = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushTest()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.pTests = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.pushTest()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push perf
+    BaseCommandLine.prototype.pushPerf = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({
+                                typeofCommit: 'performance',
+                                commitMessageRequired: true,
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push ci
+    BaseCommandLine.prototype.pushCi = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({ typeofCommit: 'ci', commitMessageRequired: true })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / select branch
+    BaseCommandLine.prototype.branch = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var branchName, branches;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.project.struct()];
+                    case 2:
+                        _a.sent();
+                        branchName = this.firstArg;
+                        branches = this.__filterBranchesByPattern(branchName);
+                        if (!(branches.length > 0)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.__selectBrach(branches, 'checkout')];
+                    case 3:
+                        branchName = _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        index_1.Helpers.error("No branch found by name \"".concat(branchName, "\""), false, true);
+                        _a.label = 5;
+                    case 5:
+                        this.project.git.checkout(branchName);
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / push build
+    BaseCommandLine.prototype.pushBuild = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.meltUpdateCommits()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.push({ typeofCommit: 'build', commitMessageRequired: true })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / set origin
+    BaseCommandLine.prototype.SET_ORIGIN = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var newOriginNameOrUrl, proj;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        newOriginNameOrUrl = this.firstArg;
+                        proj = this.project;
+                        if (proj && proj.git.isInsideGitRepo) {
+                            proj.run("git remote rm origin").sync();
+                            proj.run("git remote add origin ".concat(newOriginNameOrUrl, " ")).sync();
+                            index_1.Helpers.info("Done");
+                        }
+                        else {
+                            index_1.Helpers.error("This folder is not a git repo... ", false, true);
+                        }
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / rename origin
+    BaseCommandLine.prototype.RENAME_ORIGIN = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var newOriginNameOrUrl, proj;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        newOriginNameOrUrl = this.firstArg;
+                        proj = this.project;
+                        if (proj && proj.git.isInsideGitRepo) {
+                            proj.git.renameOrigin(newOriginNameOrUrl);
+                        }
+                        else {
+                            index_1.Helpers.error("This folder is not a git repo... ", false, true);
+                        }
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / last hash tag
+    BaseCommandLine.prototype.LAST_TAG_HASH = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        index_1.Helpers.info(this.project.git.lastTagHash());
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / last tag
+    BaseCommandLine.prototype.LAST_TAG = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var proj;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        proj = this.project;
+                        index_1.Helpers.info("\n\n    last tag: ".concat(proj.git.lastTagVersionName, "\n    last tag hash: ").concat(proj.git.lastTagHash(), "\n\n"));
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / check tag exists
+    BaseCommandLine.prototype.CHECK_TAG_EXISTS = function () {
+        index_1.Helpers.info("tag \"".concat(this.firstArg, "\"  exits = ").concat(index_1.Helpers.git.checkTagExists(this.firstArg), " "));
+        this._exit();
+    };
+    //#endregion
+    //#region commands / lint
+    /**
+     * TODO move somewhere
+     */
+    BaseCommandLine.prototype.lint = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.project.lint()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / version
+    /**
+     * TODO move somewhere
+     */
+    BaseCommandLine.prototype.version = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: false })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        console.log('Current project verison: ' + this.project.npmHelpers.version);
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / init
+    /**
+     * TODO move somewhere
+     */
+    BaseCommandLine.prototype.init = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: false })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.project.init()];
+                    case 2:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * init parent and first level children
+     */
+    BaseCommandLine.prototype.initAll = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, child, e_3_1;
+            var e_3, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: false })];
+                    case 1:
+                        if (!(_d.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.project.init()];
+                    case 2:
+                        _d.sent();
+                        _d.label = 3;
+                    case 3:
+                        _d.trys.push([3, 8, 9, 10]);
+                        _a = tslib_1.__values(this.project.children), _b = _a.next();
+                        _d.label = 4;
+                    case 4:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        child = _b.value;
+                        return [4 /*yield*/, child.init()];
+                    case 5:
+                        _d.sent();
+                        _d.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_3_1 = _d.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 10:
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / struct
+    /**
+     * TODO move somewhere
+     */
+    BaseCommandLine.prototype.struct = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: false })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.project.struct()];
+                    case 2:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / info
+    /**
+     * TODO move somewhere
+     */
+    BaseCommandLine.prototype.info = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({
+                            requireProjectWithGitRoot: false,
+                        })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        index_1.Helpers.clearConsole();
+                        return [4 /*yield*/, this.project.info()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this.project.linkedProjects.saveAllLinkedProjectsToDB()];
+                    case 3:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / info
+    BaseCommandLine.prototype.modified = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var proj, libs;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: true })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        proj = this.project;
+                        libs = proj.children.filter(function (child) {
+                            process.stdout.write('.');
+                            return child.git.thereAreSomeUncommitedChangeExcept([
+                                tnp_config_2.config.file.package_json,
+                            ]);
+                        });
+                        console.log('\n' + index_1.Helpers.terminalLine());
+                        index_1.Helpers.info(libs.length
+                            ? libs
+                                .map(function (c) {
+                                return "".concat(tnp_core_1.chalk.bold(c.name), " (").concat(c.git.uncommitedFiles.map(function (p) { return tnp_core_1.chalk.black(tnp_core_1.path.basename(p)); }).join(', '), ")");
+                            })
+                                .join('\n')
+                            : 'Nothing modifed');
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / update
+    BaseCommandLine.prototype.UPDATE = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var linkedProjects;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        linkedProjects = index_1.LinkedProject.detect(this.project.location).filter(function (linkedProj) {
+                            return _this.project.ins.From([
+                                _this.project.location,
+                                linkedProj.relativeClonePath,
+                            ]);
+                        });
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo("\n\n    Deteced project:\n".concat(linkedProjects.map(function (l) { return "- ".concat(l.relativeClonePath); }).join('\n'), "\n\n\nWould you like to update current project configuration?"))];
+                    case 1:
+                        if (_a.sent()) {
+                            this.project.linkedProjects.addLinkedProjects(linkedProjects);
+                        }
+                        return [4 /*yield*/, this.project.init()];
+                    case 2:
+                        _a.sent();
+                        index_1.Helpers.info("Linked projects updated");
+                        this._exit(0);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / changes
+    BaseCommandLine.prototype.changes = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c, _d, chil, _e, _f, e_4_1;
+            var e_4, _g;
+            return tslib_1.__generator(this, function (_h) {
+                switch (_h.label) {
+                    case 0:
+                        _b = (_a = index_1.Helpers).info;
+                        return [4 /*yield*/, this.project.git.changesSummary()];
+                    case 1:
+                        _b.apply(_a, [_h.sent()]);
+                        index_1.Helpers.terminalLine();
+                        _h.label = 2;
+                    case 2:
+                        _h.trys.push([2, 7, 8, 9]);
+                        _c = tslib_1.__values(this.project.children), _d = _c.next();
+                        _h.label = 3;
+                    case 3:
+                        if (!!_d.done) return [3 /*break*/, 6];
+                        chil = _d.value;
+                        _f = (_e = index_1.Helpers).info;
+                        return [4 /*yield*/, chil.git.changesSummary()];
+                    case 4:
+                        _f.apply(_e, [_h.sent()]);
+                        _h.label = 5;
+                    case 5:
+                        _d = _c.next();
+                        return [3 /*break*/, 3];
+                    case 6: return [3 /*break*/, 9];
+                    case 7:
+                        e_4_1 = _h.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 9];
+                    case 8:
+                        try {
+                            if (_d && !_d.done && (_g = _c.return)) _g.call(_c);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 9:
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / branch name
+    BaseCommandLine.prototype.BRANCH_NAME = function () {
+        console.log("current branch name: \"".concat(index_1.Helpers.git.currentBranchName(process.cwd()), "\""));
+        this._exit();
+    };
+    //#endregion
+    //#region commands / remotes
+    BaseCommandLine.prototype.REMOTES = function () {
+        console.log(index_1.Helpers.git.allOrigins(this.cwd));
+        this._exit();
+    };
+    BaseCommandLine.prototype.SET_REMOTE_SSH = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.Helpers.git.changeRemoteFromHttpsToSSh(this.cwd)];
+                    case 1:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.SET_REMOTE_http = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, index_1.Helpers.git.changeRemoveFromSshToHttps(this.cwd)];
+                    case 1:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.SET_REMOTE_https = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.SET_REMOTE_http()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype._resolveChildFromArg = function () {
+        var _this = this;
+        var _a = index_1.Helpers.cliTool.resolveItemFromArgsBegin(this.args, function (arg) {
+            return _this.ins.From([_this.cwd, arg]);
+        }), projFromArg = _a.resolved, clearedCommand = _a.clearedCommand;
+        if (!!projFromArg) {
+            this.args = clearedCommand.split(' ');
+            this.cwd = projFromArg.location;
+            this.project = projFromArg;
+        }
+    };
+    BaseCommandLine.prototype.origin = function () {
+        this._resolveChildFromArg();
+        console.log(index_1.Helpers.git.getOriginURL(this.cwd));
+        this._exit();
+    };
+    BaseCommandLine.prototype.remote = function () {
+        console.log(index_1.Helpers.git.getOriginURL(this.cwd));
+        this._exit();
+    };
+    BaseCommandLine.prototype.originHttp = function () {
+        console.log(index_1.Helpers.git.originSshToHttp(index_1.Helpers.git.getOriginURL(this.cwd)));
+        this._exit();
+    };
+    BaseCommandLine.prototype.originHttps = function () {
+        console.log(index_1.Helpers.git.originSshToHttp(index_1.Helpers.git.getOriginURL(this.cwd)));
+        this._exit();
+    };
+    BaseCommandLine.prototype.originssh = function () {
+        console.log(index_1.Helpers.git.originHttpToSsh(index_1.Helpers.git.getOriginURL(this.cwd)));
+        this._exit();
+    };
+    BaseCommandLine.prototype.origins = function () {
+        this.REMOTES();
+    };
+    //#endregion
+    //#region commands / git config
+    BaseCommandLine.prototype.gitConfig = function () {
+        var root = index_1.Helpers.git.findGitRoot(this.cwd);
+        index_1.Helpers.run("code ".concat((0, tnp_core_2.crossPlatformPath)([root, '.git', 'config']))).sync();
+        this._exit();
+    };
+    //#endregion
+    //#region commands / lastCommitHash
+    BaseCommandLine.prototype.LAST_COMMIT_HASH = function () {
+        console.log(index_1.Helpers.git.lastCommitHash(this.cwd));
+        this._exit();
+    };
+    //#endregion
+    //#region commands / commit message by hash
+    BaseCommandLine.prototype.COMMIT_MESSAGE_BY_HASH = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var hash, _a, _b;
+            return tslib_1.__generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        hash = this.firstArg;
+                        _b = (_a = console).log;
+                        return [4 /*yield*/, this.project.git.getCommitMessageByHash(hash)];
+                    case 1:
+                        _b.apply(_a, [_c.sent()]);
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / last 5 commit hashes
+    BaseCommandLine.prototype.LAST_5_COMMITS = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var index, hash;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        index = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(index < 5)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.project.git.getCommitHashByIndex(index)];
+                    case 2:
+                        hash = _a.sent();
+                        console.log(hash);
+                        _a.label = 3;
+                    case 3:
+                        index++;
+                        return [3 /*break*/, 1];
+                    case 4:
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / update deps from
+    BaseCommandLine.prototype.updateDepsFrom = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var locations;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                locations = this.args.join(' ').trim() === '' ? [] : this.args;
+                if (tnp_core_1._.isArray(locations)) {
+                    locations = locations.map(function (l) {
+                        if (tnp_core_1.path.isAbsolute(l)) {
+                            return tnp_core_1.path.resolve(l);
+                        }
+                        return tnp_core_1.path.resolve(tnp_core_1.path.join(_this.cwd, l));
+                    });
+                }
+                this.project.npmHelpers.updateDepsFrom(locations);
+                this._exit();
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region is terminal supported
+    BaseCommandLine.prototype.isTerminalSupported = function () {
+        console.log("Terminal is supported: ".concat(index_1.Helpers.isSupportedTaonTerminal));
+        this._exit();
+    };
+    //#endregion
+    //#region prox ext
+    BaseCommandLine.prototype.INSTALL_PROJECT_EXTENSIONS = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.INSTALL_PROJ_EXT()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.INSTALL_PROJECT_EXT = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.INSTALL_PROJ_EXT()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.INS_PROJ_EXT = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.INSTALL_PROJ_EXT()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.INSTALL_PROJ_EXT = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var p, extensions, menuItems, extensionsToInstall, index, extname;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: false })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        this.project.vsCodeHelpers.recreateExtensions();
+                        p = this.project.pathFor('.vscode/extensions.json');
+                        extensions = index_1.Helpers.readJson(p, { recommendations: [] }, true);
+                        menuItems = extensions.recommendations.map(function (r) {
+                            return { name: r, value: r, enabled: true, selected: true };
+                        });
+                        extensionsToInstall = [];
+                        _a.label = 2;
+                    case 2:
+                        if (!true) return [3 /*break*/, 5];
+                        index_1.Helpers.clearConsole();
+                        return [4 /*yield*/, index_1.Helpers.consoleGui.multiselect('Select extensions to install', menuItems, true, menuItems)];
+                    case 3:
+                        extensionsToInstall = _a.sent();
+                        index_1.Helpers.info(extensionsToInstall.join(', '));
+                        return [4 /*yield*/, index_1.Helpers.questionYesNo("Install extensions ?")];
+                    case 4:
+                        if (!(_a.sent())) {
+                            return [3 /*break*/, 2];
+                        }
+                        return [3 /*break*/, 5];
+                    case 5:
+                        for (index = 0; index < extensionsToInstall.length; index++) {
+                            extname = extensionsToInstall[index];
+                            try {
+                                index_1.Helpers.taskStarted("Installing: ".concat(extname));
+                                index_1.Helpers.run("code --install-extension ".concat(extname)).sync();
+                                index_1.Helpers.taskDone("Installed: ".concat(extname));
+                            }
+                            catch (error) {
+                                index_1.Helpers.warn("Not able to install ".concat(extname));
+                                index_1.Helpers.pressKeyOrWait('Press any key to continue...');
+                            }
+                        }
+                        index_1.Helpers.info('Done installing');
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region proj db
+    BaseCommandLine.prototype.projdb = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cwdIsProject({ requireProjectWithGitRoot: false })];
+                    case 1:
+                        if (!(_a.sent())) {
+                            return [2 /*return*/];
+                        }
+                        index_1.Helpers.info("Projects db location:\n    ".concat(this.project.linkedProjects.projectsDbLocation, "\n\n    opening in vscode...\n\n    "));
+                        index_1.Helpers.run("code ".concat(this.project.linkedProjects.projectsDbLocation)).sync();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region filter all project branches by pattern
+    BaseCommandLine.prototype.__filterBranchesByPattern = function (branchPatternOrBranchName) {
+        var branches = index_1.Helpers.arrays.uniqArray(this.project.git.getBranchesNamesBy(branchPatternOrBranchName) ||
+            this.project.getMainBranches());
+        // console.log('branches', branches);
+        return branches;
+    };
+    //#endregion
+    //#region select branch from list of branches
+    BaseCommandLine.prototype.__selectBrach = function (branches, task) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var childrenMsg;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        childrenMsg = this.project.children.length == 0
+                            ? '(no children in project)'
+                            : '(with children)';
+                        return [4 /*yield*/, index_1.Helpers.autocompleteAsk("Choose branch to ".concat(task, " in this project ").concat(childrenMsg, ": "), branches.map(function (b) {
+                                return { name: b, value: b };
+                            }))];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / clone
+    BaseCommandLine.prototype.clone = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var url, originType;
+            return tslib_1.__generator(this, function (_a) {
+                url = this.firstArg;
+                originType = this.params['setOrigin'];
+                if (originType) {
+                    if (originType === 'ssh') {
+                        url = index_1.Helpers.git.originHttpToSsh(url);
+                    }
+                    if (originType === 'http') {
+                        url = index_1.Helpers.git.originSshToHttp(url);
+                    }
+                }
+                index_1.Helpers.git.clone({
+                    url: url,
+                    cwd: this.cwd,
+                });
+                this._exit();
+                return [2 /*return*/];
+            });
+        });
+    };
+    //#endregion
+    //#region commands / ghtemp
+    BaseCommandLine.prototype.ghSave = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new gh_temp_code_1.GhTempCode(this.cwd, this.project).init().save()];
+                    case 1:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    BaseCommandLine.prototype.ghRestore = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, new gh_temp_code_1.GhTempCode(this.cwd, this.project).init().restore()];
+                    case 1:
+                        _a.sent();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / start cli service ports worker
+    BaseCommandLine.prototype.startCliServicePortsWorker = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.ins.portsWorker.cliStartProcedure(this.params)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    //#endregion
+    //#region commands / pause terminal
+    BaseCommandLine.prototype.pauseTerminal = function () {
+        index_1.Helpers.pressKeyAndContinue();
+        this._exit();
+    };
+    //#endregion
+    //#region commands / gh pages init
+    BaseCommandLine.prototype.ghPagesInit = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.project.init()];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.project.githubPages.init(this.params['provider'] || 'github', !!this.params['full'])];
+                    case 2:
+                        _a.sent();
+                        index_1.Helpers.run('code .', {
+                            cwd: this.project.githubPages.mainFolderAbsPath,
+                        }).sync();
+                        this._exit();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return BaseCommandLine;
+}(command_line_feature_backend_1.CommandLineFeature));
+exports.BaseCommandLine = BaseCommandLine;
+//# sourceMappingURL=base-command-line.backend.js.map