rman 0.3.0 → 0.6.0

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',
+                cwd: 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 { cwd } = args;
+            await this._fsDelete(path.join(cwd, 'node_modules'));
+            await this._fsDelete(path.join(cwd, 'package-lock.json'));
+            await this._fsDelete(path.join(cwd, '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();
@@ -31,6 +29,9 @@ export class MultiTaskCommand extends Command {
         });
         await this._task.toPromise().catch(() => void (0));
     }
+    async _getPackages() {
+        return this.repository.getPackages({ toposort: !this.options.parallel });
+    }
 }
 (function (MultiTaskCommand) {
     MultiTaskCommand.cliCommandOptions = {

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;
+        cwd: 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,30 @@ 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;
+        cwd: string;
+        dependencies?: string[];
+    }, ctx?: any): Task | undefined;
+    protected _exec(args: {
+        name: string;
+        cwd: string;
+        dependencies?: string[];
+        command: string;
+        stdio?: 'inherit' | 'pipe';
+        json?: any;
+        logLevel?: string;
+        noThrow?: boolean;
+    }, 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,26 +11,45 @@ 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,
+                    cwd: p.dirname,
+                    json: p.json,
+                    dependencies: p.dependencies
+                }, options);
                 if (childTask) {
-                    tasks.push(childTask);
+                    packageTasks.push(childTask);
                 }
             }
         }
+        const mainTask = this._prepareScriptTask({
+            name: 'root',
+            cwd: 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;
         }
@@ -43,37 +61,41 @@ export class RunCommand extends MultiTaskCommand {
             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: p.name + ':' + s.name,
+                    name: args.name + ':' + s.name,
                     dependencies: s.name.startsWith('pre') || s.name.startsWith('post') ?
-                        undefined : p.dependencies
+                        undefined : args.dependencies
                 });
                 children.push(task);
             }
         }
         if (children.length) {
             return new Task(children, {
-                name: p.name,
+                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) {
+        const logLevel = args.logLevel == null ? 'info' : args.logLevel;
+        if (logLevel)
+            logger.log(logLevel, this.commandName, chalk.cyan(args.name), chalk.cyanBright.bold('executing'), logger.separator, args.command);
         const t = Date.now();
-        const r = await exec(command, options);
-        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);
-        }
-        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'));
-        if (r.error)
+        const r = await exec(args.command, { cwd: args.cwd, stdio: args.stdio });
+        if (logLevel)
+            if (r.error) {
+                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.log(logLevel, this.commandName, chalk.cyan(args.name), chalk.green.bold('executed'), logger.separator, args.command, chalk.yellow(' (' + (Date.now() - t) + ' ms)'));
+        if (r.error && !args.noThrow)
             throw r.error;
         return r;
     }

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

@@ -3,21 +3,27 @@ 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;
+        cwd: string;
+        dependencies?: string[];
+        command: string;
+    }, options?: any): Promise<ExecuteCommandResult>;
 }
 export declare namespace VersionCommand {
     interface Options extends RunCommand.Options {
         unified?: boolean;
         all?: boolean;
         ignoreDirty?: boolean;
-        forceDirty?: boolean;
+        noTag?: boolean;
     }
     const cliCommandOptions: Record<string, yargs.Options>;
     function initCli(repository: Repository, program: yargs.Argv): void;

package/esm/commands/version-command.mjs

@@ -1,25 +1,24 @@
 import path from 'path';
-import fs from 'fs';
 import chalk from 'chalk';
 import semver from 'semver';
 import logger from 'npmlog';
 import stripColor from 'strip-color';
-import figures from 'figures';
+import { Task } from 'power-tasks';
 import { RunCommand } from './run-command.mjs';
 import { GitHelper } from './../utils/git-utils.mjs';
 import { Command } from './../core/command.mjs';
+import fs from 'fs/promises';
 export class VersionCommand extends RunCommand {
     constructor(repository, bump, options) {
         super(repository, 'version', options);
         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 = [];
@@ -29,7 +28,7 @@ export class VersionCommand extends RunCommand {
             let message = '';
             let newVer = '';
             const logPkgName = chalk.yellow(p.name);
-            if (!this.options.forceDirty) {
+            if (!this.options.noTag) {
                 const isDirty = dirtyFiles.find(f => !path.relative(relDir, f).startsWith('..'));
                 if (isDirty) {
                     if (!this.options.ignoreDirty)
@@ -60,47 +59,63 @@ 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);
         }
         if (errorCount)
             throw new Error('Unable to bump version due to error(s)');
+        const maxVer = Object.values(newVersions).reduce((m, v) => {
+            return semver.gt(m, v) ? m : v;
+        }, '0.0.0');
         if (this.options.unified) {
-            const maxVer = Object.values(newVersions).reduce((m, v) => {
-                return semver.gt(m, v) ? m : v;
-            }, '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);
-            }
-        }
+        const tasks = await super._prepareTasks(selectedPackages, { newVersions });
+        tasks.forEach(t => t.options.exclusive = true);
+        if (this.options.unified)
+            tasks.push(new Task(async () => {
+                try {
+                    await super._exec({
+                        name: 'rman',
+                        command: 'git tag -a "v' + maxVer + '" -m "version ' + maxVer + '"',
+                        cwd: this.repository.dirname,
+                        stdio: logger.levelIndex <= 1000 ? 'inherit' : 'pipe',
+                        logLevel: 'silly'
+                    });
+                }
+                catch {
+                    //
+                }
+            }, { exclusive: true }));
         return tasks;
     }
-    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;
-            delete pkg.json.scripts.version;
-            const f = path.join(pkg.dirname, 'package.json');
-            const data = JSON.stringify(pkg.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));
+    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.cwd, 'package.json');
+            const data = JSON.stringify(args.json, undefined, 2);
+            await fs.writeFile(f, data, 'utf-8');
+            if (!this.options.noTag) {
+                await super._exec({
+                    name: args.name,
+                    command: 'git commit -m "' + newVer + '" package.json',
+                    cwd: args.cwd,
+                    stdio: logger.levelIndex <= 1000 ? 'inherit' : 'pipe',
+                    logLevel: 'silly'
+                });
+            }
+            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';
@@ -118,12 +133,12 @@ VersionCommand.commandName = 'version';
         },
         'ignore-dirty': {
             alias: 'i',
-            describe: '# Ignore dirty packages',
+            describe: '# Do not bump version for dirty packages',
             type: 'boolean'
         },
-        'force-dirty': {
-            alias: 'f',
-            describe: '# Force bump version for dirty packages',
+        'no-tag': {
+            alias: 'n',
+            describe: '# Do not crate git version tag. (Ignores dirty check)',
             type: 'boolean'
         }
     };

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;