rman 0.2.5 → 0.5.1

package/cjs/cli.js

@@ -18,6 +18,7 @@ const execute_command_1 = require("./commands/execute-command");
 const run_command_1 = require("./commands/run-command");
 const version_command_1 = require("./commands/version-command");
 const publish_command_1 = require("./commands/publish-command");
+const ci_command_1 = require("./commands/ci-command");
 async function runCli(options) {
     const s = path_1.default.resolve((0, utils_1.getDirname)(), '../package.json');
     const pkgJson = JSON.parse(await promises_1.default.readFile(s, 'utf-8'));
@@ -48,6 +49,7 @@ async function runCli(options) {
     run_command_1.RunCommand.initCli(repository, program);
     version_command_1.VersionCommand.initCli(repository, program);
     publish_command_1.PublishCommand.initCli(repository, program);
+    ci_command_1.CleanInstallCommand.initCli(repository, program);
     if (!_argv.length)
         program.showHelp();
     else

package/cjs/commands/ci-command.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CleanInstallCommand = void 0;
+const power_tasks_1 = require("power-tasks");
+const chalk_1 = __importDefault(require("chalk"));
+const npmlog_1 = __importDefault(require("npmlog"));
+const command_1 = require("../core/command");
+const run_command_1 = require("./run-command");
+const file_utils_1 = require("../utils/file-utils");
+const path_1 = __importDefault(require("path"));
+class CleanInstallCommand extends run_command_1.RunCommand {
+    constructor(repository, options) {
+        super(repository, 'clean_', options);
+        this.repository = repository;
+    }
+    async _prepareTasks(packages) {
+        const tasks = await super._prepareTasks(packages);
+        const client = this.repository.config.client || 'npm';
+        if (!(client === 'npm' || client === 'yargs'))
+            throw new Error(`Invalid npm client "${client}"`);
+        tasks.push(new power_tasks_1.Task(async () => {
+            const dirname = this.repository.dirname;
+            await this._fsDelete(path_1.default.join(dirname, 'node_modules'));
+            await this._fsDelete(path_1.default.join(dirname, 'package-lock.json'));
+            await this._fsDelete(path_1.default.join(dirname, 'yarn-lock.json'));
+            npmlog_1.default.info(this.commandName, chalk_1.default.yellow('installing'), 'Running ' + client + ' install');
+            return super._exec({
+                name: 'root',
+                dirname: this.repository.dirname,
+                json: { ...this.repository.json },
+                command: client + ' install',
+                stdio: 'inherit'
+            });
+        }, { exclusive: true }));
+        return tasks;
+    }
+    async _exec(args, ctx) {
+        if (args.command === '#') {
+            if (args.name === 'root')
+                return { code: 0 };
+            const { dirname } = args;
+            await this._fsDelete(path_1.default.join(dirname, 'node_modules'));
+            await this._fsDelete(path_1.default.join(dirname, 'package-lock.json'));
+            await this._fsDelete(path_1.default.join(dirname, 'yarn-lock.json'));
+            return { code: 0 };
+        }
+        return super._exec(args, ctx);
+    }
+    async _fsDelete(fileOrDir) {
+        if (await (0, file_utils_1.fsExists)(fileOrDir)) {
+            npmlog_1.default.info(this.commandName, chalk_1.default.yellow('clean'), 'Deleting ' + fileOrDir);
+            await (0, file_utils_1.fsDelete)(fileOrDir);
+        }
+    }
+}
+exports.CleanInstallCommand = CleanInstallCommand;
+CleanInstallCommand.commandName = 'ci';
+(function (CleanInstallCommand) {
+    CleanInstallCommand.cliCommandOptions = {
+        ...run_command_1.RunCommand.cliCommandOptions
+    };
+    function initCli(repository, program) {
+        program.command({
+            command: 'ci [...options]',
+            describe: 'Deletes all dependency modules and re-installs',
+            builder: (cmd) => {
+                return cmd
+                    .example("$0 ci", '')
+                    .option(CleanInstallCommand.cliCommandOptions);
+            },
+            handler: async (args) => {
+                const options = command_1.Command.composeOptions(CleanInstallCommand.commandName, args, repository.config);
+                await new CleanInstallCommand(repository, options).execute();
+            }
+        });
+    }
+    CleanInstallCommand.initCli = initCli;
+})(CleanInstallCommand = exports.CleanInstallCommand || (exports.CleanInstallCommand = {}));

package/cjs/commands/execute-command.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ExecuteCommand = void 0;
 const npmlog_1 = __importDefault(require("npmlog"));
 const chalk_1 = __importDefault(require("chalk"));
-const figures_1 = __importDefault(require("figures"));
 const multi_task_command_1 = require("./multi-task-command");
 const power_tasks_1 = require("power-tasks");
 const exec_1 = require("../utils/exec");
@@ -18,18 +17,18 @@ class ExecuteCommand extends multi_task_command_1.MultiTaskCommand {
         this.cmd = cmd;
         this.argv = argv;
     }
-    _prepareTasks() {
-        const packages = this.repository.getPackages({ toposort: !this.options.parallel });
+    _prepareTasks(packages) {
         const tasks = [];
         for (const p of packages) {
             const task = new power_tasks_1.Task(async () => {
                 const t = Date.now();
-                npmlog_1.default.verbose(this.commandName, p.name, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), chalk_1.default.cyanBright.bold('executing'), chalk_1.default.gray(figures_1.default.lineVerticalDashed0), this.cmd + ' ' + (this.argv?.join(' ') || ''));
+                npmlog_1.default.verbose(this.commandName, p.name, chalk_1.default.cyanBright.bold('executing'), npmlog_1.default.separator, this.cmd + ' ' + (this.argv?.join(' ') || ''));
                 const r = await (0, exec_1.exec)(this.cmd, {
                     cwd: p.dirname,
-                    argv: this.argv
+                    argv: this.argv,
+                    stdio: npmlog_1.default.levelIndex <= 1000 ? 'inherit' : 'pipe'
                 });
-                npmlog_1.default.log((r.error ? 'error' : 'verbose'), this.commandName, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), p.name, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), (r.error ? chalk_1.default.red.bold('failed') : chalk_1.default.green.bold('success')), chalk_1.default.gray(figures_1.default.lineVerticalDashed0), 'Completed in ' + chalk_1.default.yellow('' + (Date.now() - t) + ' ms'));
+                npmlog_1.default.log((r.error ? 'error' : 'info'), this.commandName, p.name, (r.error ? chalk_1.default.red.bold('failed') : chalk_1.default.green.bold('success')), npmlog_1.default.separator, this.cmd, chalk_1.default.yellow(' (' + (Date.now() - t) + ' ms') + ')');
             }, {
                 name: p.name,
                 dependencies: this.options.parallel ? undefined : p.dependencies,

package/cjs/commands/multi-task-command.js

@@ -5,13 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultiTaskCommand = void 0;
 const os_1 = __importDefault(require("os"));
-const chalk_1 = __importDefault(require("chalk"));
 const npmlog_1 = __importDefault(require("npmlog"));
-const figures_1 = __importDefault(require("figures"));
 const power_tasks_1 = require("power-tasks");
 const command_1 = require("../core/command");
 const constants_1 = require("../utils/constants");
-const logSeparator = chalk_1.default.gray(figures_1.default.lineVerticalDashed0);
 class MultiTaskCommand extends command_1.Command {
     constructor(repository, options) {
         super(options);
@@ -25,9 +22,10 @@ class MultiTaskCommand extends command_1.Command {
             this.options.bail = true;
     }
     async _execute() {
-        const childTasks = await this._prepareTasks();
+        const packages = await this._getPackages();
+        const childTasks = await this._prepareTasks(packages);
         if (!(childTasks && childTasks.length)) {
-            npmlog_1.default.info(this.commandName, logSeparator, 'There is no task to process');
+            npmlog_1.default.info(this.commandName, '', 'There is no task to process');
             return;
         }
         // this.enableProgress();
@@ -35,7 +33,10 @@ class MultiTaskCommand extends command_1.Command {
             concurrency: this.options.concurrency || os_1.default.cpus().length,
             bail: this.options.bail,
         });
-        await this._task.catch(() => void (0));
+        await this._task.toPromise().catch(() => void (0));
+    }
+    async _getPackages() {
+        return this.repository.getPackages({ toposort: !this.options.parallel });
     }
 }
 exports.MultiTaskCommand = MultiTaskCommand;

package/cjs/commands/publish-command.js

@@ -7,7 +7,6 @@ exports.PublishCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const package_json_1 = __importDefault(require("package-json"));
 const npmlog_1 = __importDefault(require("npmlog"));
-const figures_1 = __importDefault(require("figures"));
 const command_1 = require("../core/command");
 const run_command_1 = require("./run-command");
 class PublishCommand extends run_command_1.RunCommand {
@@ -15,33 +14,27 @@ class PublishCommand extends run_command_1.RunCommand {
         super(repository, 'publish', options);
         this.repository = repository;
     }
-    async _prepareTasks() {
-        const { repository } = this;
-        const packages = repository.getPackages({ toposort: true });
+    async _prepareTasks(packages) {
         const newVersions = {};
         const selectedPackages = [];
         for (const p of packages) {
             const logPkgName = chalk_1.default.yellow(p.name);
             const r = await (0, package_json_1.default)(p.json.name);
             if (r.version === p.version) {
-                npmlog_1.default.info(this.commandName, logPkgName, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), `Ignored. Same version (${p.version}) in repository`);
+                npmlog_1.default.info(this.commandName, logPkgName, npmlog_1.default.separator, `Ignored. Same version (${p.version}) in repository`);
                 continue;
             }
             selectedPackages.push(p);
         }
-        const tasks = [];
-        for (const p of selectedPackages) {
-            const json = { ...p.json };
-            json.scripts = json.scripts || {};
-            json.scripts.publish = json.scripts.publish || 'npm publish';
-            const _p = { json };
-            Object.setPrototypeOf(_p, p);
-            const childTask = this._preparePackageTask(_p, { newVersions });
-            if (childTask) {
-                tasks.push(childTask);
-            }
+        return super._prepareTasks(selectedPackages, { newVersions });
+    }
+    async _exec(args, options) {
+        if (args.command === '#') {
+            if (args.name === 'root')
+                return { code: 0 };
+            return super._exec({ ...args, command: 'npm publish' }, { ...options, stdio: 'inherit' });
         }
-        return tasks;
+        return super._exec(args, options);
     }
 }
 exports.PublishCommand = PublishCommand;

package/cjs/commands/run-command.js

@@ -7,7 +7,6 @@ exports.RunCommand = void 0;
 const npmlog_1 = __importDefault(require("npmlog"));
 const power_tasks_1 = require("power-tasks");
 const chalk_1 = __importDefault(require("chalk"));
-const figures_1 = __importDefault(require("figures"));
 const parse_npm_script_1 = __importDefault(require("@netlify/parse-npm-script"));
 const multi_task_command_1 = require("./multi-task-command");
 const command_1 = require("../core/command");
@@ -18,63 +17,87 @@ class RunCommand extends multi_task_command_1.MultiTaskCommand {
         this.repository = repository;
         this.script = script;
     }
-    async _preExecute() {
-        npmlog_1.default.info('run', `Executing script "${this.script}" for packages`);
-    }
-    _prepareTasks() {
-        const packages = this.repository.getPackages({ toposort: true });
-        const tasks = [];
+    _prepareTasks(packages, options) {
+        const packageTasks = [];
         for (const p of packages) {
             if (p.json.scripts) {
-                const childTask = this._preparePackageTask(p);
+                const childTask = this._prepareScriptTask({
+                    name: p.name,
+                    dirname: p.dirname,
+                    json: p.json,
+                    dependencies: p.dependencies
+                }, options);
                 if (childTask) {
-                    tasks.push(childTask);
+                    packageTasks.push(childTask);
                 }
             }
         }
+        const mainTask = this._prepareScriptTask({
+            name: 'root',
+            dirname: this.repository.dirname,
+            json: this.repository.json
+        });
+        if (!mainTask?.children)
+            return packageTasks;
+        const tasks = [];
+        const pre = mainTask.children.filter((t => t.name.endsWith(':pre' + this.script)));
+        const post = mainTask.children.filter((t => t.name.endsWith(':post' + this.script)));
+        pre.forEach(t => t.options.exclusive = true);
+        post.forEach(t => t.options.exclusive = true);
+        tasks.push(...pre);
+        tasks.push(...packageTasks);
+        tasks.push(...post);
         return tasks;
     }
-    _preparePackageTask(p, ctx) {
+    _prepareScriptTask(args, ctx) {
+        const json = { ...args.json };
+        json.scripts = json.scripts || {};
+        json.scripts[this.script] = json.scripts[this.script] || '#';
         let scriptInfo;
         try {
-            scriptInfo = (0, parse_npm_script_1.default)(p.json, 'npm run ' + this.script);
+            scriptInfo = (0, parse_npm_script_1.default)(json, 'npm run ' + this.script);
             if (!(scriptInfo && scriptInfo.raw))
                 return;
         }
         catch {
             return;
         }
-        const tasks = [];
+        const children = [];
         for (const s of scriptInfo.steps) {
             const parsed = Array.isArray(s.parsed) ? s.parsed : [s.parsed];
             for (const cmd of parsed) {
                 const task = new power_tasks_1.Task(async () => {
-                    return await this._exec(p, cmd, {
-                        cwd: p.dirname,
-                        argv: this.argv
+                    return await this._exec({
+                        ...args,
+                        command: cmd,
+                        stdio: npmlog_1.default.levelIndex <= 1000 ? 'inherit' : 'pipe'
                     }, ctx);
+                }, {
+                    name: args.name + ':' + s.name,
+                    dependencies: s.name.startsWith('pre') || s.name.startsWith('post') ?
+                        undefined : args.dependencies
                 });
-                tasks.push(task);
+                children.push(task);
             }
         }
-        if (tasks.length)
-            return new power_tasks_1.Task(tasks, {
-                name: p.name,
-                dependencies: this.options.parallel ? undefined : p.dependencies,
-                bail: this.options.bail,
-                concurrency: this.options.concurrency
+        if (children.length) {
+            return new power_tasks_1.Task(children, {
+                name: args.name,
+                bail: true,
+                serial: true,
             });
+        }
     }
-    async _exec(pkg, command, options, ctx) {
-        npmlog_1.default.verbose(this.commandName, pkg.name, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), chalk_1.default.cyanBright.bold('executing'), chalk_1.default.gray(figures_1.default.lineVerticalDashed0), command);
+    async _exec(args, options) {
+        npmlog_1.default.verbose(this.commandName, chalk_1.default.cyan(args.name), chalk_1.default.cyanBright.bold('executing'), npmlog_1.default.separator, args.command);
         const t = Date.now();
-        const r = await (0, exec_1.exec)(command, options);
+        const r = await (0, exec_1.exec)(args.command, { cwd: args.dirname, stdio: args.stdio });
         if (r.error) {
-            npmlog_1.default.error(this.commandName, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), pkg.name, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), chalk_1.default.red.bold('failed'), chalk_1.default.gray(figures_1.default.lineVerticalDashed0), command, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), r.error.message.trim());
-            npmlog_1.default.verbose(this.commandName, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), r.stderr || r.stdout);
+            npmlog_1.default.error(this.commandName, chalk_1.default.cyan(args.name), chalk_1.default.red.bold('failed'), npmlog_1.default.separator, args.command, npmlog_1.default.separator, r.error.message.trim());
+            npmlog_1.default.verbose(this.commandName, '', r.stderr || r.stdout);
         }
         else
-            npmlog_1.default.info(this.commandName, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), pkg.name, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), chalk_1.default.green.bold('success'), chalk_1.default.gray(figures_1.default.lineVerticalDashed0), command, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), 'Completed in ' + chalk_1.default.yellow('' + (Date.now() - t) + ' ms'));
+            npmlog_1.default.info(this.commandName, chalk_1.default.cyan(args.name), chalk_1.default.green.bold('executed'), npmlog_1.default.separator, args.command, chalk_1.default.yellow(' (' + (Date.now() - t) + ' ms)'));
         if (r.error)
             throw r.error;
         return r;

package/cjs/commands/version-command.js

@@ -10,7 +10,6 @@ const chalk_1 = __importDefault(require("chalk"));
 const semver_1 = __importDefault(require("semver"));
 const npmlog_1 = __importDefault(require("npmlog"));
 const strip_color_1 = __importDefault(require("strip-color"));
-const figures_1 = __importDefault(require("figures"));
 const run_command_1 = require("./run-command");
 const git_utils_1 = require("../utils/git-utils");
 const command_1 = require("../core/command");
@@ -20,12 +19,11 @@ class VersionCommand extends run_command_1.RunCommand {
         this.repository = repository;
         this.bump = bump;
     }
-    async _prepareTasks() {
+    async _prepareTasks(packages) {
         const { repository } = this;
         const git = new git_utils_1.GitHelper({ cwd: repository.dirname });
         const dirtyFiles = await git.listDirtyFiles();
         const committedFiles = await git.listCommittedFiles();
-        const packages = repository.getPackages({ toposort: true });
         const newVersions = {};
         let errorCount = 0;
         const selectedPackages = [];
@@ -66,7 +64,7 @@ class VersionCommand extends run_command_1.RunCommand {
                         message: (0, strip_color_1.default)(message),
                     });
                 else
-                    npmlog_1.default.log(this.options.ignoreDirty ? 'info' : 'error', this.commandName, logPkgName, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), chalk_1.default.whiteBright(p.version), chalk_1.default.gray(figures_1.default.lineVerticalDashed0), status, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), message);
+                    npmlog_1.default.log(this.options.ignoreDirty ? 'info' : 'error', this.commandName, logPkgName, chalk_1.default.whiteBright(p.version), status, npmlog_1.default.separator, message);
                 continue;
             }
             selectedPackages.push(p);
@@ -79,33 +77,24 @@ class VersionCommand extends run_command_1.RunCommand {
             }, '0.0.0');
             Object.keys(newVersions).forEach(k => newVersions[k] = maxVer);
         }
-        const tasks = [];
-        for (const p of selectedPackages) {
-            const json = { ...p.json };
-            json.scripts = json.scripts || {};
-            json.scripts.version = json.scripts.version || '#version';
-            const _p = { json };
-            Object.setPrototypeOf(_p, p);
-            const childTask = this._preparePackageTask(_p, { newVersions });
-            if (childTask) {
-                tasks.push(childTask);
-            }
-        }
-        return tasks;
+        return super._prepareTasks(selectedPackages, { newVersions });
     }
-    async _exec(pkg, command, options, ctx) {
-        if (command === '#version') {
-            const { newVersions } = ctx;
-            const oldVer = pkg.version;
-            const newVer = newVersions[pkg.name];
-            pkg.json.version = newVer;
-            const f = path_1.default.join(pkg.dirname, 'package.json');
-            const data = JSON.stringify(pkg.json, undefined, 2);
+    async _exec(args, options) {
+        if (args.name === 'root')
+            return { code: 0 };
+        if (args.command === '#') {
+            const { newVersions } = options;
+            const oldVer = args.json.version;
+            const newVer = newVersions[args.name];
+            args.json.version = newVer;
+            delete args.json.scripts.version;
+            const f = path_1.default.join(args.dirname, 'package.json');
+            const data = JSON.stringify(args.json, undefined, 2);
             fs_1.default.writeFileSync(f, data, 'utf-8');
-            npmlog_1.default.info(this.commandName, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), pkg.name, chalk_1.default.gray(figures_1.default.lineVerticalDashed0), 'Version changed from ' + chalk_1.default.cyan(oldVer) + ' to ' + chalk_1.default.cyan(newVer));
+            npmlog_1.default.info(this.commandName, args.name, npmlog_1.default.separator, 'Version changed from ' + chalk_1.default.cyan(oldVer) + ' to ' + chalk_1.default.cyan(newVer));
             return { code: 0 };
         }
-        return super._exec(pkg, command, options);
+        return super._exec(args, options);
     }
 }
 exports.VersionCommand = VersionCommand;

package/cjs/core/command.js

@@ -10,6 +10,9 @@ const is_ci_1 = __importDefault(require("is-ci"));
 const putil_merge_1 = __importDefault(require("putil-merge"));
 require("./logger");
 const constants_1 = require("../utils/constants");
+const chalk_1 = __importDefault(require("chalk"));
+const figures_1 = __importDefault(require("figures"));
+const npmlog_2 = __importDefault(require("npmlog"));
 const noOp = () => void (0);
 class Command extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_typed_events_1.AsyncEventEmitter) {
     constructor(options) {
@@ -20,6 +23,12 @@ class Command extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_t
         this._options = options || {};
         if (is_ci_1.default)
             this.options.ci = true;
+        this.logger.separator = chalk_1.default.gray(figures_1.default.lineVerticalDashed0);
+        Object.defineProperty(this.logger, 'levelIndex', {
+            get() {
+                return npmlog_2.default.levels[npmlog_2.default.level] || 0;
+            }
+        });
     }
     get options() {
         return this._options;
@@ -56,7 +65,7 @@ class Command extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_t
             await this.emitAsync('finish', undefined, v).catch(noOp);
             this.disableProgress();
             this.logger.resume();
-            this.logger.success('', 'Command completed');
+            this.logger.info('', 'Command completed');
             return v;
         }
         catch (e) {
@@ -76,6 +85,10 @@ class Command extends (0, strict_typed_events_1.TypedEventEmitterClass)(strict_t
             return;
     }
     disableProgress() {
+        //
+    }
+    async _preExecute() {
+        npmlog_2.default.info('rman', `Executing "${this.commandName}" command`);
     }
 }
 exports.Command = Command;
@@ -100,8 +113,8 @@ exports.Command = Command;
     function composeOptions(commandName, yargArgs, config) {
         const result = (0, putil_merge_1.default)({}, yargArgs);
         (0, putil_merge_1.default)(result, config, { filter: (_, key) => key !== 'command' });
-        const cfgCmd = config.commans && typeof config.command === 'object' ?
-            config.command : undefined;
+        const cfgCmd = config.command && typeof config.command === 'object' ?
+            config.command[commandName] : undefined;
         if (cfgCmd && typeof cfgCmd === 'object')
             (0, putil_merge_1.default)(result, cfgCmd);
         return result;

package/cjs/core/logger.js

@@ -4,5 +4,4 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const npmlog_1 = __importDefault(require("npmlog"));
-npmlog_1.default.addLevel("success", 1500, { fg: "green", bold: true });
 npmlog_1.default.addLevel('output', 3300, {}, '');

package/cjs/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

package/cjs/utils/file-utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsDelete = exports.tryStat = exports.fsExists = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+async function fsExists(s) {
+    return promises_1.default.lstat(s).then(() => true).catch(() => false);
+}
+exports.fsExists = fsExists;
+async function tryStat(s) {
+    return promises_1.default.lstat(s).catch(() => undefined);
+}
+exports.tryStat = tryStat;
+async function fsDelete(fileOrDir) {
+    const stat = await tryStat(fileOrDir);
+    if (stat) {
+        if (stat.isFile() || stat.isSymbolicLink()) {
+            await promises_1.default.unlink(fileOrDir);
+            return true;
+        }
+        if (stat.isDirectory()) {
+            const list = await promises_1.default.readdir(fileOrDir);
+            for (const file of list)
+                await fsDelete(path_1.default.join(fileOrDir, file));
+            await promises_1.default.rmdir(fileOrDir);
+            return true;
+        }
+    }
+    return false;
+}
+exports.fsDelete = fsDelete;

package/esm/cli.mjs

@@ -12,6 +12,7 @@ import { ExecuteCommand } from './commands/execute-command.mjs';
 import { RunCommand } from './commands/run-command.mjs';
 import { VersionCommand } from './commands/version-command.mjs';
 import { PublishCommand } from './commands/publish-command.mjs';
+import { CleanInstallCommand } from './commands/ci-command.mjs';
 export async function runCli(options) {
     const s = path.resolve(getDirname(), '../package.json');
     const pkgJson = JSON.parse(await fs.readFile(s, 'utf-8'));
@@ -42,6 +43,7 @@ export async function runCli(options) {
     RunCommand.initCli(repository, program);
     VersionCommand.initCli(repository, program);
     PublishCommand.initCli(repository, program);
+    CleanInstallCommand.initCli(repository, program);
     if (!_argv.length)
         program.showHelp();
     else

package/esm/commands/ci-command.d.ts

@@ -0,0 +1,26 @@
+import yargs from 'yargs';
+import { Task } from 'power-tasks';
+import { Repository } from '../core/repository';
+import { Package } from '../core/package';
+import { RunCommand } from './run-command';
+import { ExecuteCommandResult } from '../utils/exec';
+export declare class CleanInstallCommand extends RunCommand<CleanInstallCommand.Options> {
+    readonly repository: Repository;
+    static commandName: string;
+    constructor(repository: Repository, options?: CleanInstallCommand.Options);
+    protected _prepareTasks(packages: Package[]): Promise<Task[]>;
+    protected _exec(args: {
+        name: string;
+        json: any;
+        dirname: string;
+        dependencies?: string[];
+        command: string;
+    }, ctx?: any): Promise<ExecuteCommandResult>;
+    protected _fsDelete(fileOrDir: string): Promise<void>;
+}
+export declare namespace CleanInstallCommand {
+    interface Options extends RunCommand.Options {
+    }
+    const cliCommandOptions: Record<string, yargs.Options>;
+    function initCli(repository: Repository, program: yargs.Argv): void;
+}

package/esm/commands/ci-command.mjs

@@ -0,0 +1,74 @@
+import { Task } from 'power-tasks';
+import chalk from 'chalk';
+import logger from 'npmlog';
+import { Command } from './../core/command.mjs';
+import { RunCommand } from './run-command.mjs';
+import { fsDelete, fsExists } from './../utils/file-utils.mjs';
+import path from 'path';
+export class CleanInstallCommand extends RunCommand {
+    constructor(repository, options) {
+        super(repository, 'clean_', options);
+        this.repository = repository;
+    }
+    async _prepareTasks(packages) {
+        const tasks = await super._prepareTasks(packages);
+        const client = this.repository.config.client || 'npm';
+        if (!(client === 'npm' || client === 'yargs'))
+            throw new Error(`Invalid npm client "${client}"`);
+        tasks.push(new Task(async () => {
+            const dirname = this.repository.dirname;
+            await this._fsDelete(path.join(dirname, 'node_modules'));
+            await this._fsDelete(path.join(dirname, 'package-lock.json'));
+            await this._fsDelete(path.join(dirname, 'yarn-lock.json'));
+            logger.info(this.commandName, chalk.yellow('installing'), 'Running ' + client + ' install');
+            return super._exec({
+                name: 'root',
+                dirname: this.repository.dirname,
+                json: { ...this.repository.json },
+                command: client + ' install',
+                stdio: 'inherit'
+            });
+        }, { exclusive: true }));
+        return tasks;
+    }
+    async _exec(args, ctx) {
+        if (args.command === '#') {
+            if (args.name === 'root')
+                return { code: 0 };
+            const { dirname } = args;
+            await this._fsDelete(path.join(dirname, 'node_modules'));
+            await this._fsDelete(path.join(dirname, 'package-lock.json'));
+            await this._fsDelete(path.join(dirname, 'yarn-lock.json'));
+            return { code: 0 };
+        }
+        return super._exec(args, ctx);
+    }
+    async _fsDelete(fileOrDir) {
+        if (await fsExists(fileOrDir)) {
+            logger.info(this.commandName, chalk.yellow('clean'), 'Deleting ' + fileOrDir);
+            await fsDelete(fileOrDir);
+        }
+    }
+}
+CleanInstallCommand.commandName = 'ci';
+(function (CleanInstallCommand) {
+    CleanInstallCommand.cliCommandOptions = {
+        ...RunCommand.cliCommandOptions
+    };
+    function initCli(repository, program) {
+        program.command({
+            command: 'ci [...options]',
+            describe: 'Deletes all dependency modules and re-installs',
+            builder: (cmd) => {
+                return cmd
+                    .example("$0 ci", '')
+                    .option(CleanInstallCommand.cliCommandOptions);
+            },
+            handler: async (args) => {
+                const options = Command.composeOptions(CleanInstallCommand.commandName, args, repository.config);
+                await new CleanInstallCommand(repository, options).execute();
+            }
+        });
+    }
+    CleanInstallCommand.initCli = initCli;
+})(CleanInstallCommand || (CleanInstallCommand = {}));

package/esm/commands/execute-command.d.ts

@@ -2,13 +2,14 @@ import yargs from 'yargs';
 import { Repository } from '../core/repository';
 import { MultiTaskCommand } from './multi-task-command';
 import { Task } from 'power-tasks';
+import { Package } from '../core/package';
 export declare class ExecuteCommand extends MultiTaskCommand<ExecuteCommand.Options> {
     readonly repository: Repository;
     cmd: string;
     argv?: string[] | undefined;
     static commandName: string;
     constructor(repository: Repository, cmd: string, argv?: string[] | undefined, options?: ExecuteCommand.Options);
-    protected _prepareTasks(): Task[];
+    protected _prepareTasks(packages: Package[]): Task[];
 }
 export declare namespace ExecuteCommand {
     interface Options extends MultiTaskCommand.Options {

package/esm/commands/execute-command.mjs

@@ -1,6 +1,5 @@
 import logger from 'npmlog';
 import chalk from 'chalk';
-import figures from 'figures';
 import { MultiTaskCommand } from './multi-task-command.mjs';
 import { Task } from 'power-tasks';
 import { exec } from './../utils/exec.mjs';
@@ -12,18 +11,18 @@ export class ExecuteCommand extends MultiTaskCommand {
         this.cmd = cmd;
         this.argv = argv;
     }
-    _prepareTasks() {
-        const packages = this.repository.getPackages({ toposort: !this.options.parallel });
+    _prepareTasks(packages) {
         const tasks = [];
         for (const p of packages) {
             const task = new Task(async () => {
                 const t = Date.now();
-                logger.verbose(this.commandName, p.name, chalk.gray(figures.lineVerticalDashed0), chalk.cyanBright.bold('executing'), chalk.gray(figures.lineVerticalDashed0), this.cmd + ' ' + (this.argv?.join(' ') || ''));
+                logger.verbose(this.commandName, p.name, chalk.cyanBright.bold('executing'), logger.separator, this.cmd + ' ' + (this.argv?.join(' ') || ''));
                 const r = await exec(this.cmd, {
                     cwd: p.dirname,
-                    argv: this.argv
+                    argv: this.argv,
+                    stdio: logger.levelIndex <= 1000 ? 'inherit' : 'pipe'
                 });
-                logger.log((r.error ? 'error' : 'verbose'), this.commandName, chalk.gray(figures.lineVerticalDashed0), p.name, chalk.gray(figures.lineVerticalDashed0), (r.error ? chalk.red.bold('failed') : chalk.green.bold('success')), chalk.gray(figures.lineVerticalDashed0), 'Completed in ' + chalk.yellow('' + (Date.now() - t) + ' ms'));
+                logger.log((r.error ? 'error' : 'info'), this.commandName, p.name, (r.error ? chalk.red.bold('failed') : chalk.green.bold('success')), logger.separator, this.cmd, chalk.yellow(' (' + (Date.now() - t) + ' ms') + ')');
             }, {
                 name: p.name,
                 dependencies: this.options.parallel ? undefined : p.dependencies,

package/esm/commands/multi-task-command.d.ts

@@ -2,12 +2,14 @@ import yargs from 'yargs';
 import { Task } from 'power-tasks';
 import { Repository } from '../core/repository';
 import { Command } from '../core/command';
+import { Package } from '../core/package';
 export declare abstract class MultiTaskCommand<TOptions extends MultiTaskCommand.Options = MultiTaskCommand.Options> extends Command<TOptions> {
     readonly repository: Repository;
     protected _task?: Task;
     protected constructor(repository: Repository, options?: TOptions);
     protected _execute(): Promise<any>;
-    protected abstract _prepareTasks(): Task[] | Promise<Task[]> | void;
+    protected _getPackages(): Promise<Package[]>;
+    protected abstract _prepareTasks(packages: Package[]): Task[] | Promise<Task[]> | void;
 }
 export declare namespace MultiTaskCommand {
     interface Options extends Command.GlobalOptions {

package/esm/commands/multi-task-command.mjs

@@ -1,11 +1,8 @@
 import os from 'os';
-import chalk from 'chalk';
 import logger from 'npmlog';
-import figures from 'figures';
 import { Task } from 'power-tasks';
 import { Command } from './../core/command.mjs';
 import { isTTY } from './../utils/constants.mjs';
-const logSeparator = chalk.gray(figures.lineVerticalDashed0);
 export class MultiTaskCommand extends Command {
     constructor(repository, options) {
         super(options);
@@ -19,9 +16,10 @@ export class MultiTaskCommand extends Command {
             this.options.bail = true;
     }
     async _execute() {
-        const childTasks = await this._prepareTasks();
+        const packages = await this._getPackages();
+        const childTasks = await this._prepareTasks(packages);
         if (!(childTasks && childTasks.length)) {
-            logger.info(this.commandName, logSeparator, 'There is no task to process');
+            logger.info(this.commandName, '', 'There is no task to process');
             return;
         }
         // this.enableProgress();
@@ -29,7 +27,10 @@ export class MultiTaskCommand extends Command {
             concurrency: this.options.concurrency || os.cpus().length,
             bail: this.options.bail,
         });
-        await this._task.catch(() => void (0));
+        await this._task.toPromise().catch(() => void (0));
+    }
+    async _getPackages() {
+        return this.repository.getPackages({ toposort: !this.options.parallel });
     }
 }
 (function (MultiTaskCommand) {

package/esm/commands/publish-command.d.ts

@@ -1,12 +1,21 @@
 import yargs from 'yargs';
 import { Task } from 'power-tasks';
 import { Repository } from '../core/repository';
+import { Package } from '../core/package';
 import { RunCommand } from './run-command';
+import { ExecuteCommandResult } from '../utils/exec';
 export declare class PublishCommand extends RunCommand<PublishCommand.Options> {
     readonly repository: Repository;
     static commandName: string;
     constructor(repository: Repository, options?: PublishCommand.Options);
-    protected _prepareTasks(): Promise<Task[]>;
+    protected _prepareTasks(packages: Package[]): Promise<Task[]>;
+    protected _exec(args: {
+        name: string;
+        json: any;
+        dirname: string;
+        dependencies?: string[];
+        command: string;
+    }, options?: any): Promise<ExecuteCommandResult>;
 }
 export declare namespace PublishCommand {
     interface Options extends RunCommand.Options {

package/esm/commands/publish-command.mjs

@@ -1,7 +1,6 @@
 import chalk from 'chalk';
 import fetchPackageInfo from 'package-json';
 import logger from 'npmlog';
-import figures from 'figures';
 import { Command } from './../core/command.mjs';
 import { RunCommand } from './run-command.mjs';
 export class PublishCommand extends RunCommand {
@@ -9,33 +8,27 @@ export class PublishCommand extends RunCommand {
         super(repository, 'publish', options);
         this.repository = repository;
     }
-    async _prepareTasks() {
-        const { repository } = this;
-        const packages = repository.getPackages({ toposort: true });
+    async _prepareTasks(packages) {
         const newVersions = {};
         const selectedPackages = [];
         for (const p of packages) {
             const logPkgName = chalk.yellow(p.name);
             const r = await fetchPackageInfo(p.json.name);
             if (r.version === p.version) {
-                logger.info(this.commandName, logPkgName, chalk.gray(figures.lineVerticalDashed0), `Ignored. Same version (${p.version}) in repository`);
+                logger.info(this.commandName, logPkgName, logger.separator, `Ignored. Same version (${p.version}) in repository`);
                 continue;
             }
             selectedPackages.push(p);
         }
-        const tasks = [];
-        for (const p of selectedPackages) {
-            const json = { ...p.json };
-            json.scripts = json.scripts || {};
-            json.scripts.publish = json.scripts.publish || 'npm publish';
-            const _p = { json };
-            Object.setPrototypeOf(_p, p);
-            const childTask = this._preparePackageTask(_p, { newVersions });
-            if (childTask) {
-                tasks.push(childTask);
-            }
+        return super._prepareTasks(selectedPackages, { newVersions });
+    }
+    async _exec(args, options) {
+        if (args.command === '#') {
+            if (args.name === 'root')
+                return { code: 0 };
+            return super._exec({ ...args, command: 'npm publish' }, { ...options, stdio: 'inherit' });
         }
-        return tasks;
+        return super._exec(args, options);
     }
 }
 PublishCommand.commandName = 'publish';

package/esm/commands/run-command.d.ts

@@ -2,17 +2,28 @@ import yargs from 'yargs';
 import { Task } from 'power-tasks';
 import { Repository } from '../core/repository';
 import { MultiTaskCommand } from './multi-task-command';
+import { ExecuteCommandResult } from '../utils/exec';
 import { Package } from '../core/package';
-import { ExecuteCommandResult, IExecutorOptions } from '../utils/exec';
 export declare class RunCommand<TOptions extends RunCommand.Options> extends MultiTaskCommand<TOptions> {
     readonly repository: Repository;
     script: string;
     static commandName: string;
     constructor(repository: Repository, script: string, options?: TOptions);
-    protected _preExecute(): Promise<void>;
-    protected _prepareTasks(): Task[] | Promise<Task[]>;
-    protected _preparePackageTask(p: Package, ctx?: any): Task | undefined;
-    protected _exec(pkg: Package, command: string, options: IExecutorOptions, ctx?: any): Promise<ExecuteCommandResult>;
+    protected _prepareTasks(packages: Package[], options?: any): Task[] | Promise<Task[]>;
+    protected _prepareScriptTask(args: {
+        name: string;
+        json: any;
+        dirname: string;
+        dependencies?: string[];
+    }, ctx?: any): Task | undefined;
+    protected _exec(args: {
+        name: string;
+        json: any;
+        dirname: string;
+        dependencies?: string[];
+        command: string;
+        stdio?: 'inherit' | 'pipe';
+    }, options?: any): Promise<ExecuteCommandResult>;
 }
 export declare namespace RunCommand {
     interface Options extends MultiTaskCommand.Options {

package/esm/commands/run-command.mjs

@@ -1,7 +1,6 @@
 import logger from 'npmlog';
 import { Task } from 'power-tasks';
 import chalk from 'chalk';
-import figures from 'figures';
 import parseNpmScript from '@netlify/parse-npm-script';
 import { MultiTaskCommand } from './multi-task-command.mjs';
 import { Command } from './../core/command.mjs';
@@ -12,63 +11,87 @@ export class RunCommand extends MultiTaskCommand {
         this.repository = repository;
         this.script = script;
     }
-    async _preExecute() {
-        logger.info('run', `Executing script "${this.script}" for packages`);
-    }
-    _prepareTasks() {
-        const packages = this.repository.getPackages({ toposort: true });
-        const tasks = [];
+    _prepareTasks(packages, options) {
+        const packageTasks = [];
         for (const p of packages) {
             if (p.json.scripts) {
-                const childTask = this._preparePackageTask(p);
+                const childTask = this._prepareScriptTask({
+                    name: p.name,
+                    dirname: p.dirname,
+                    json: p.json,
+                    dependencies: p.dependencies
+                }, options);
                 if (childTask) {
-                    tasks.push(childTask);
+                    packageTasks.push(childTask);
                 }
             }
         }
+        const mainTask = this._prepareScriptTask({
+            name: 'root',
+            dirname: this.repository.dirname,
+            json: this.repository.json
+        });
+        if (!mainTask?.children)
+            return packageTasks;
+        const tasks = [];
+        const pre = mainTask.children.filter((t => t.name.endsWith(':pre' + this.script)));
+        const post = mainTask.children.filter((t => t.name.endsWith(':post' + this.script)));
+        pre.forEach(t => t.options.exclusive = true);
+        post.forEach(t => t.options.exclusive = true);
+        tasks.push(...pre);
+        tasks.push(...packageTasks);
+        tasks.push(...post);
         return tasks;
     }
-    _preparePackageTask(p, ctx) {
+    _prepareScriptTask(args, ctx) {
+        const json = { ...args.json };
+        json.scripts = json.scripts || {};
+        json.scripts[this.script] = json.scripts[this.script] || '#';
         let scriptInfo;
         try {
-            scriptInfo = parseNpmScript(p.json, 'npm run ' + this.script);
+            scriptInfo = parseNpmScript(json, 'npm run ' + this.script);
             if (!(scriptInfo && scriptInfo.raw))
                 return;
         }
         catch {
             return;
         }
-        const tasks = [];
+        const children = [];
         for (const s of scriptInfo.steps) {
             const parsed = Array.isArray(s.parsed) ? s.parsed : [s.parsed];
             for (const cmd of parsed) {
                 const task = new Task(async () => {
-                    return await this._exec(p, cmd, {
-                        cwd: p.dirname,
-                        argv: this.argv
+                    return await this._exec({
+                        ...args,
+                        command: cmd,
+                        stdio: logger.levelIndex <= 1000 ? 'inherit' : 'pipe'
                     }, ctx);
+                }, {
+                    name: args.name + ':' + s.name,
+                    dependencies: s.name.startsWith('pre') || s.name.startsWith('post') ?
+                        undefined : args.dependencies
                 });
-                tasks.push(task);
+                children.push(task);
             }
         }
-        if (tasks.length)
-            return new Task(tasks, {
-                name: p.name,
-                dependencies: this.options.parallel ? undefined : p.dependencies,
-                bail: this.options.bail,
-                concurrency: this.options.concurrency
+        if (children.length) {
+            return new Task(children, {
+                name: args.name,
+                bail: true,
+                serial: true,
             });
+        }
     }
-    async _exec(pkg, command, options, ctx) {
-        logger.verbose(this.commandName, pkg.name, chalk.gray(figures.lineVerticalDashed0), chalk.cyanBright.bold('executing'), chalk.gray(figures.lineVerticalDashed0), command);
+    async _exec(args, options) {
+        logger.verbose(this.commandName, chalk.cyan(args.name), chalk.cyanBright.bold('executing'), logger.separator, args.command);
         const t = Date.now();
-        const r = await exec(command, options);
+        const r = await exec(args.command, { cwd: args.dirname, stdio: args.stdio });
         if (r.error) {
-            logger.error(this.commandName, chalk.gray(figures.lineVerticalDashed0), pkg.name, chalk.gray(figures.lineVerticalDashed0), chalk.red.bold('failed'), chalk.gray(figures.lineVerticalDashed0), command, chalk.gray(figures.lineVerticalDashed0), r.error.message.trim());
-            logger.verbose(this.commandName, chalk.gray(figures.lineVerticalDashed0), r.stderr || r.stdout);
+            logger.error(this.commandName, chalk.cyan(args.name), chalk.red.bold('failed'), logger.separator, args.command, logger.separator, r.error.message.trim());
+            logger.verbose(this.commandName, '', r.stderr || r.stdout);
         }
         else
-            logger.info(this.commandName, chalk.gray(figures.lineVerticalDashed0), pkg.name, chalk.gray(figures.lineVerticalDashed0), chalk.green.bold('success'), chalk.gray(figures.lineVerticalDashed0), command, chalk.gray(figures.lineVerticalDashed0), 'Completed in ' + chalk.yellow('' + (Date.now() - t) + ' ms'));
+            logger.info(this.commandName, chalk.cyan(args.name), chalk.green.bold('executed'), logger.separator, args.command, chalk.yellow(' (' + (Date.now() - t) + ' ms)'));
         if (r.error)
             throw r.error;
         return r;

package/esm/commands/version-command.d.ts

@@ -3,14 +3,20 @@ import { Task } from 'power-tasks';
 import { Repository } from '../core/repository';
 import { RunCommand } from './run-command';
 import { Package } from '../core/package';
-import { ExecuteCommandResult, IExecutorOptions } from '../utils/exec';
+import { ExecuteCommandResult } from '../utils/exec';
 export declare class VersionCommand extends RunCommand<VersionCommand.Options> {
     readonly repository: Repository;
     bump: string;
     static commandName: string;
     constructor(repository: Repository, bump: string, options?: VersionCommand.Options);
-    protected _prepareTasks(): Promise<Task[]>;
-    protected _exec(pkg: Package, command: string, options: IExecutorOptions, ctx: any): Promise<ExecuteCommandResult>;
+    protected _prepareTasks(packages: Package[]): Promise<Task[]>;
+    protected _exec(args: {
+        name: string;
+        json: any;
+        dirname: string;
+        dependencies?: string[];
+        command: string;
+    }, options?: any): Promise<ExecuteCommandResult>;
 }
 export declare namespace VersionCommand {
     interface Options extends RunCommand.Options {

package/esm/commands/version-command.mjs

@@ -4,7 +4,6 @@ import chalk from 'chalk';
 import semver from 'semver';
 import logger from 'npmlog';
 import stripColor from 'strip-color';
-import figures from 'figures';
 import { RunCommand } from './run-command.mjs';
 import { GitHelper } from './../utils/git-utils.mjs';
 import { Command } from './../core/command.mjs';
@@ -14,12 +13,11 @@ export class VersionCommand extends RunCommand {
         this.repository = repository;
         this.bump = bump;
     }
-    async _prepareTasks() {
+    async _prepareTasks(packages) {
         const { repository } = this;
         const git = new GitHelper({ cwd: repository.dirname });
         const dirtyFiles = await git.listDirtyFiles();
         const committedFiles = await git.listCommittedFiles();
-        const packages = repository.getPackages({ toposort: true });
         const newVersions = {};
         let errorCount = 0;
         const selectedPackages = [];
@@ -60,7 +58,7 @@ export class VersionCommand extends RunCommand {
                         message: stripColor(message),
                     });
                 else
-                    logger.log(this.options.ignoreDirty ? 'info' : 'error', this.commandName, logPkgName, chalk.gray(figures.lineVerticalDashed0), chalk.whiteBright(p.version), chalk.gray(figures.lineVerticalDashed0), status, chalk.gray(figures.lineVerticalDashed0), message);
+                    logger.log(this.options.ignoreDirty ? 'info' : 'error', this.commandName, logPkgName, chalk.whiteBright(p.version), status, logger.separator, message);
                 continue;
             }
             selectedPackages.push(p);
@@ -73,33 +71,24 @@ export class VersionCommand extends RunCommand {
             }, '0.0.0');
             Object.keys(newVersions).forEach(k => newVersions[k] = maxVer);
         }
-        const tasks = [];
-        for (const p of selectedPackages) {
-            const json = { ...p.json };
-            json.scripts = json.scripts || {};
-            json.scripts.version = json.scripts.version || '#version';
-            const _p = { json };
-            Object.setPrototypeOf(_p, p);
-            const childTask = this._preparePackageTask(_p, { newVersions });
-            if (childTask) {
-                tasks.push(childTask);
-            }
-        }
-        return tasks;
+        return super._prepareTasks(selectedPackages, { newVersions });
     }
-    async _exec(pkg, command, options, ctx) {
-        if (command === '#version') {
-            const { newVersions } = ctx;
-            const oldVer = pkg.version;
-            const newVer = newVersions[pkg.name];
-            pkg.json.version = newVer;
-            const f = path.join(pkg.dirname, 'package.json');
-            const data = JSON.stringify(pkg.json, undefined, 2);
+    async _exec(args, options) {
+        if (args.name === 'root')
+            return { code: 0 };
+        if (args.command === '#') {
+            const { newVersions } = options;
+            const oldVer = args.json.version;
+            const newVer = newVersions[args.name];
+            args.json.version = newVer;
+            delete args.json.scripts.version;
+            const f = path.join(args.dirname, 'package.json');
+            const data = JSON.stringify(args.json, undefined, 2);
             fs.writeFileSync(f, data, 'utf-8');
-            logger.info(this.commandName, chalk.gray(figures.lineVerticalDashed0), pkg.name, chalk.gray(figures.lineVerticalDashed0), 'Version changed from ' + chalk.cyan(oldVer) + ' to ' + chalk.cyan(newVer));
+            logger.info(this.commandName, args.name, logger.separator, 'Version changed from ' + chalk.cyan(oldVer) + ' to ' + chalk.cyan(newVer));
             return { code: 0 };
         }
-        return super._exec(pkg, command, options);
+        return super._exec(args, options);
     }
 }
 VersionCommand.commandName = 'version';

package/esm/core/command.d.ts

@@ -20,7 +20,7 @@ export declare abstract class Command<TOptions extends Command.GlobalOptions = C
     protected enableProgress(): Promise<void>;
     protected disableProgress(): void;
     protected abstract _execute(): Promise<any>;
-    protected _preExecute?(): Promise<void>;
+    protected _preExecute(): Promise<void>;
     protected _postExecute?(): Promise<void>;
 }
 export declare namespace Command {

package/esm/core/command.mjs

@@ -4,6 +4,9 @@ import isCi from 'is-ci';
 import merge from 'putil-merge';
 import './logger.mjs';
 import { isTTY } from './../utils/constants.mjs';
+import chalk from 'chalk';
+import figures from 'figures';
+import logger from 'npmlog';
 const noOp = () => void (0);
 export class Command extends TypedEventEmitterClass(AsyncEventEmitter) {
     constructor(options) {
@@ -14,6 +17,12 @@ export class Command extends TypedEventEmitterClass(AsyncEventEmitter) {
         this._options = options || {};
         if (isCi)
             this.options.ci = true;
+        this.logger.separator = chalk.gray(figures.lineVerticalDashed0);
+        Object.defineProperty(this.logger, 'levelIndex', {
+            get() {
+                return logger.levels[logger.level] || 0;
+            }
+        });
     }
     get options() {
         return this._options;
@@ -50,7 +59,7 @@ export class Command extends TypedEventEmitterClass(AsyncEventEmitter) {
             await this.emitAsync('finish', undefined, v).catch(noOp);
             this.disableProgress();
             this.logger.resume();
-            this.logger.success('', 'Command completed');
+            this.logger.info('', 'Command completed');
             return v;
         }
         catch (e) {
@@ -70,6 +79,10 @@ export class Command extends TypedEventEmitterClass(AsyncEventEmitter) {
             return;
     }
     disableProgress() {
+        //
+    }
+    async _preExecute() {
+        logger.info('rman', `Executing "${this.commandName}" command`);
     }
 }
 (function (Command) {
@@ -93,8 +106,8 @@ export class Command extends TypedEventEmitterClass(AsyncEventEmitter) {
     function composeOptions(commandName, yargArgs, config) {
         const result = merge({}, yargArgs);
         merge(result, config, { filter: (_, key) => key !== 'command' });
-        const cfgCmd = config.commans && typeof config.command === 'object' ?
-            config.command : undefined;
+        const cfgCmd = config.command && typeof config.command === 'object' ?
+            config.command[commandName] : undefined;
         if (cfgCmd && typeof cfgCmd === 'object')
             merge(result, cfgCmd);
         return result;

package/esm/core/logger.d.ts

@@ -5,6 +5,8 @@ declare module 'npmlog' {
         disp: Record<string, string>;
         showProgress(): any;
         hideProgress(): any;
+        separator: string;
+        levelIndex: number;
     }
 }
 export {};

package/esm/core/logger.mjs

@@ -1,3 +1,2 @@
 import logger from 'npmlog';
-logger.addLevel("success", 1500, { fg: "green", bold: true });
 logger.addLevel('output', 3300, {}, '');

package/esm/utils/file-utils.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { Stats } from 'node:fs';
+export declare function fsExists(s: string): Promise<boolean>;
+export declare function tryStat(s: any): Promise<Stats | undefined>;
+export declare function fsDelete(fileOrDir: string): Promise<boolean>;

package/esm/utils/file-utils.mjs

@@ -0,0 +1,25 @@
+import fsa from 'fs/promises';
+import path from 'path';
+export async function fsExists(s) {
+    return fsa.lstat(s).then(() => true).catch(() => false);
+}
+export async function tryStat(s) {
+    return fsa.lstat(s).catch(() => undefined);
+}
+export async function fsDelete(fileOrDir) {
+    const stat = await tryStat(fileOrDir);
+    if (stat) {
+        if (stat.isFile() || stat.isSymbolicLink()) {
+            await fsa.unlink(fileOrDir);
+            return true;
+        }
+        if (stat.isDirectory()) {
+            const list = await fsa.readdir(fileOrDir);
+            for (const file of list)
+                await fsDelete(path.join(fileOrDir, file));
+            await fsa.rmdir(fileOrDir);
+            return true;
+        }
+    }
+    return false;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Monorepo repository manager",
-  "version": "0.2.5",
+  "version": "0.5.1",
   "author": "Panates",
   "license": "MIT",
   "contributors": [
@@ -43,7 +43,7 @@
     "npmlog": "^6.0.0",
     "package-json": "^7.0.0",
     "path-key": "^4.0.0",
-    "power-tasks": "^0.0.2",
+    "power-tasks": "^0.4.0",
     "putil-merge": "^3.7.0",
     "putil-varhelpers": "^1.6.3",
     "semver": "^7.3.5",