rman 0.19.0 → 0.21.0

package/cjs/commands/ci-command.js

@@ -27,27 +27,23 @@ class CleanInstallCommand extends run_command_js_1.RunCommand {
             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',
-                cwd: this.repository.dirname,
-                json: { ...this.repository.json },
-                command: client + ' install',
+            return super._exec(this.repository.rootPackage, client + ' install', {
                 stdio: 'inherit'
             });
         }, { exclusive: true }));
         return tasks;
     }
-    async _exec(args, ctx) {
+    async _exec(pkg, command, args, ctx) {
         if (args.command === '#') {
-            if (args.name === 'root')
+            if (pkg === this.repository.rootPackage)
                 return { code: 0 };
-            const { cwd } = args;
+            const cwd = args.cwd || pkg.dirname;
             await this._fsDelete(path_1.default.join(cwd, 'node_modules'));
             await this._fsDelete(path_1.default.join(cwd, 'package-lock.json'));
             await this._fsDelete(path_1.default.join(cwd, 'yarn-lock.json'));
             return { code: 0 };
         }
-        return super._exec(args, ctx);
+        return super._exec(pkg, command, args, ctx);
     }
     async _fsDelete(fileOrDir) {
         if (await (0, file_utils_js_1.fsExists)(fileOrDir)) {

package/cjs/commands/publish-command.js

@@ -57,23 +57,20 @@ class PublishCommand extends run_command_js_1.RunCommand {
         await Promise.all(promises);
         return super._prepareTasks(selectedPackages, { newVersions });
     }
-    async _exec(args, options) {
-        if (args.command === '#') {
-            if (args.name === 'root')
+    async _exec(pkg, command, args, options) {
+        if (command === '#') {
+            if (pkg === this.repository.rootPackage)
                 return { code: 0 };
             const cwd = this.options.contents
-                ? path_1.default.resolve(this.repository.dirname, path_1.default.join(this.options.contents, path_1.default.basename(args.cwd)))
-                : args.cwd;
-            return super._exec({
+                ? path_1.default.resolve(this.repository.dirname, path_1.default.join(this.options.contents, path_1.default.basename(pkg.dirname)))
+                : pkg.dirname;
+            return super._exec(pkg, 'npm publish' + (this.options.access ? ' --access=' + this.options.access : ''), {
                 ...args,
                 cwd,
-                command: 'npm publish' + (this.options.access ? ' --access=' + this.options.access : '')
-            }, {
-                ...options,
-                stdio: npmlog_1.default.levelIndex < 1000 ? 'inherit' : 'pipe'
-            });
+                stdio: npmlog_1.default.levelIndex < 1000 ? 'inherit' : 'pipe',
+            }, options);
         }
-        return super._exec(args, options);
+        return super._exec(pkg, command, args, options);
     }
 }
 exports.PublishCommand = PublishCommand;

package/cjs/commands/run-command.js

@@ -21,22 +21,13 @@ class RunCommand extends multi_task_command_js_1.MultiTaskCommand {
         const packageTasks = [];
         for (const p of packages) {
             if (p.json.scripts) {
-                const childTask = this._prepareScriptTask({
-                    name: p.name,
-                    cwd: p.dirname,
-                    json: p.json,
-                    dependencies: p.dependencies
-                }, options);
+                const childTask = this._prepareScriptTask(p, options);
                 if (childTask) {
                     packageTasks.push(childTask);
                 }
             }
         }
-        const rootTask = this._prepareScriptTask({
-            name: 'root',
-            cwd: this.repository.dirname,
-            json: this.repository.json
-        });
+        const rootTask = this._prepareScriptTask(this.repository.rootPackage);
         if (!rootTask?.children)
             return packageTasks;
         const tasks = [];
@@ -49,57 +40,51 @@ class RunCommand extends multi_task_command_js_1.MultiTaskCommand {
         tasks.push(...post);
         return tasks;
     }
-    _prepareScriptTask(args, ctx) {
-        const json = { ...args.json };
+    _prepareScriptTask(pkg, options) {
+        const json = { ...pkg.json };
         json.scripts = json.scripts || {};
         json.scripts[this.script] = json.scripts[this.script] || '#';
-        let scriptInfo;
-        try {
-            scriptInfo = (0, parse_npm_script_1.default)(json, 'npm run ' + this.script);
-            if (!(scriptInfo && scriptInfo.raw))
-                return;
-        }
-        catch {
+        const scriptInfo = (0, parse_npm_script_1.default)(json, 'npm run ' + this.script);
+        if (!(scriptInfo && scriptInfo.raw))
             return;
-        }
         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({
-                        ...args,
-                        command: cmd,
+                    return await this._exec(pkg, cmd, {
                         stdio: npmlog_1.default.levelIndex < 1000 ? 'inherit' : 'pipe'
-                    }, ctx);
+                    }, options);
                 }, {
-                    name: args.name + ':' + s.name,
+                    name: pkg.name + ':' + s.name,
                     dependencies: (this.options.parallel || s.name.startsWith('pre') || s.name.startsWith('post')) ?
-                        undefined : args.dependencies
+                        undefined : pkg.dependencies
                 });
                 children.push(task);
             }
         }
         if (children.length) {
             return new power_tasks_1.Task(children, {
-                name: args.name,
+                name: pkg.name,
                 bail: true,
                 serial: true,
             });
         }
     }
-    async _exec(args, options) {
+    async _exec(pkg, command, args, options) {
+        const name = pkg === this.repository.rootPackage ? 'root' : pkg.name;
         const logLevel = args.logLevel == null ? 'info' : args.logLevel;
         if (logLevel)
-            npmlog_1.default.verbose(this.commandName, chalk_1.default.cyan(args.name), chalk_1.default.cyanBright.bold('executing'), npmlog_1.default.separator, args.command);
+            npmlog_1.default.verbose(this.commandName, chalk_1.default.cyan(name), chalk_1.default.cyanBright.bold('executing'), npmlog_1.default.separator, command);
         const t = Date.now();
-        const r = await (0, exec_js_1.exec)(args.command, { cwd: args.cwd, stdio: args.stdio, throwOnError: false });
+        const cwd = args.cwd || pkg.dirname;
+        const r = await (0, exec_js_1.exec)(command, { cwd, stdio: args.stdio, throwOnError: false });
         if (logLevel)
             if (r.error) {
-                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() + ('\n' + r.stdout).trim());
+                npmlog_1.default.error(this.commandName, chalk_1.default.cyan(name), chalk_1.default.red.bold('failed'), npmlog_1.default.separator, command, npmlog_1.default.separator, r.error.message.trim() + ('\n' + r.stdout).trim());
             }
             else
-                npmlog_1.default.log(logLevel, 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)'));
+                npmlog_1.default.log(logLevel, this.commandName, chalk_1.default.cyan(name), chalk_1.default.green.bold('executed'), npmlog_1.default.separator, command, chalk_1.default.yellow(' (' + (Date.now() - t) + ' ms)'));
         if (r.error && !args.noThrow)
             throw r.error;
         return r;

package/cjs/commands/version-command.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VersionCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
-const promises_1 = __importDefault(require("fs/promises"));
 const npmlog_1 = __importDefault(require("npmlog"));
 const path_1 = __importDefault(require("path"));
 const power_tasks_1 = require("power-tasks");
@@ -19,6 +18,7 @@ class VersionCommand extends run_command_js_1.RunCommand {
         super(repository, 'version', options);
         this.repository = repository;
         this.bump = bump;
+        this._updatedPackages = new Set();
     }
     async _prepareTasks(packages) {
         const { repository } = this;
@@ -28,6 +28,7 @@ class VersionCommand extends run_command_js_1.RunCommand {
         const newVersions = {};
         let errorCount = 0;
         const selectedPackages = [];
+        const dependentPackages = [];
         for (const p of packages) {
             const relDir = path_1.default.relative(repository.dirname, p.dirname);
             let status = '';
@@ -69,6 +70,10 @@ class VersionCommand extends run_command_js_1.RunCommand {
                 continue;
             }
             selectedPackages.push(p);
+            packages.forEach(p2 => {
+                if (p2.dependencies.includes(p.name) && !dependentPackages.includes(p2))
+                    dependentPackages.push(p2);
+            });
         }
         if (errorCount)
             throw new Error('Unable to bump version due to error(s)');
@@ -78,50 +83,74 @@ class VersionCommand extends run_command_js_1.RunCommand {
         if (this.options.unified) {
             Object.keys(newVersions).forEach(k => newVersions[k] = maxVer);
         }
+        dependentPackages.forEach(p2 => {
+            if (!selectedPackages.includes(p2))
+                selectedPackages.push(p2);
+        });
         const tasks = await super._prepareTasks(selectedPackages, { newVersions });
         tasks.forEach(t => t.options.exclusive = true);
-        if (this.options.unified)
+        if (!this.options.noTag) {
             tasks.push(new power_tasks_1.Task(async () => {
-                try {
-                    await super._exec({
-                        name: 'rman',
-                        command: 'git tag -a "v' + maxVer + '" -m "version ' + maxVer + '"',
-                        cwd: this.repository.dirname,
+                while (this._updatedPackages.size) {
+                    const filenames = [];
+                    const [first] = this._updatedPackages;
+                    for (const pkg of this._updatedPackages) {
+                        if (pkg.version === first.version) {
+                            filenames.push(path_1.default.relative(this.repository.rootPackage.dirname, pkg.jsonFileName));
+                            this._updatedPackages.delete(pkg);
+                        }
+                    }
+                    await super._exec(this.repository.rootPackage, 'git commit -m "' + first.version + '" ' + filenames.map(s => '"' + s + '"').join(' '), {
                         stdio: npmlog_1.default.levelIndex < 1000 ? 'inherit' : 'pipe',
                         logLevel: 'silly'
                     });
                 }
-                catch {
-                    //
-                }
+                if (this.options.unified)
+                    try {
+                        await super._exec(this.repository.rootPackage, 'git tag -a "v' + maxVer + '" -m "version ' + maxVer + '"', {
+                            cwd: this.repository.dirname,
+                            stdio: npmlog_1.default.levelIndex < 1000 ? 'inherit' : 'pipe',
+                            logLevel: 'silly'
+                        });
+                    }
+                    catch {
+                        //
+                    }
             }, { exclusive: true }));
+        }
         return tasks;
     }
-    async _exec(args, options) {
-        if (args.name === 'root')
+    async _exec(pkg, command, args, options) {
+        if (pkg === this.repository.rootPackage)
             return { code: 0 };
-        if (args.command === '#') {
+        if (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.cwd, 'package.json');
-            const data = JSON.stringify(args.json, undefined, 2);
-            await promises_1.default.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: npmlog_1.default.levelIndex < 1000 ? 'inherit' : 'pipe',
-                    logLevel: 'silly'
-                });
+            pkg.reloadJson();
+            const oldVer = pkg.json.version;
+            const newVer = newVersions[pkg.name];
+            pkg.json.version = newVer;
+            delete pkg.json.scripts.version;
+            pkg.writeJson();
+            if (!this._updatedPackages.has(pkg))
+                this._updatedPackages.add(pkg);
+            const packages = this.repository.getPackages();
+            for (const p of packages) {
+                if (p.dependencies.includes(pkg.name)) {
+                    p.reloadJson();
+                    for (const k of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+                        if (p.json[k]?.[pkg.name]) {
+                            p.json[k][pkg.name] = '^' + newVer;
+                        }
+                    }
+                    p.writeJson();
+                    if (!this._updatedPackages.has(p))
+                        this._updatedPackages.add(p);
+                }
             }
-            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));
+            npmlog_1.default.info(this.commandName, pkg.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(args, options);
+        return super._exec(pkg, command, args, options);
     }
 }
 exports.VersionCommand = VersionCommand;

package/cjs/core/package.js

@@ -21,13 +21,21 @@ class Package {
     get json() {
         return this._json;
     }
+    get jsonFileName() {
+        return path_1.default.join(this.dirname, 'package.json');
+    }
     get isPrivate() {
         return !!this._json.private;
     }
     reloadJson() {
-        const f = path_1.default.join(this.dirname, 'package.json');
+        const f = this.jsonFileName;
         this._json = JSON.parse(fs_1.default.readFileSync(f, 'utf-8'));
         return this._json;
     }
+    writeJson() {
+        const f = this.jsonFileName;
+        const data = JSON.stringify(this._json, undefined, 2);
+        fs_1.default.writeFileSync(f, data, 'utf-8');
+    }
 }
 exports.Package = Package;

package/cjs/core/repository.js

@@ -17,6 +17,7 @@ class Repository extends package_js_1.Package {
         this.dirname = dirname;
         this.config = config;
         this.packages = packages;
+        this.rootPackage = new package_js_1.Package(dirname);
     }
     getPackages(options) {
         const result = [...this.packages];

package/cjs/utils/exec.js

@@ -18,6 +18,8 @@ async function exec(command, options) {
         ...(0, npm_run_path_js_1.npmRunPathEnv)({ cwd: opts.cwd }),
         ...opts.env
     };
+    if (process.env.TS_NODE_PROJECT)
+        delete opts.env.TS_NODE_PROJECT;
     opts.cwd = opts.cwd || process.cwd();
     const spawnOptions = {
         stdio: opts.stdio || 'pipe',

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

@@ -9,10 +9,8 @@ export declare class CleanInstallCommand extends RunCommand<CleanInstallCommand.
     static commandName: string;
     constructor(repository: Repository, options?: CleanInstallCommand.Options);
     protected _prepareTasks(packages: Package[]): Promise<Task[]>;
-    protected _exec(args: {
-        name: string;
-        json: any;
-        cwd: string;
+    protected _exec(pkg: Package, command: string, args: {
+        cwd?: string;
         dependencies?: string[];
         command: string;
     }, ctx?: any): Promise<ExecuteCommandResult>;

package/esm/commands/ci-command.js

@@ -21,27 +21,23 @@ export class CleanInstallCommand extends RunCommand {
             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',
+            return super._exec(this.repository.rootPackage, client + ' install', {
                 stdio: 'inherit'
             });
         }, { exclusive: true }));
         return tasks;
     }
-    async _exec(args, ctx) {
+    async _exec(pkg, command, args, ctx) {
         if (args.command === '#') {
-            if (args.name === 'root')
+            if (pkg === this.repository.rootPackage)
                 return { code: 0 };
-            const { cwd } = args;
+            const cwd = args.cwd || pkg.dirname;
             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);
+        return super._exec(pkg, command, args, ctx);
     }
     async _fsDelete(fileOrDir) {
         if (await fsExists(fileOrDir)) {

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

@@ -9,13 +9,7 @@ export declare class PublishCommand extends RunCommand<PublishCommand.Options> {
     static commandName: string;
     constructor(repository: Repository, options?: PublishCommand.Options);
     protected _prepareTasks(packages: Package[]): Promise<Task[]>;
-    protected _exec(args: {
-        name: string;
-        json: any;
-        cwd: string;
-        dependencies?: string[];
-        command: string;
-    }, options?: any): Promise<ExecuteCommandResult>;
+    protected _exec(pkg: Package, command: string, args: {}, options?: any): Promise<ExecuteCommandResult>;
 }
 export declare namespace PublishCommand {
     interface Options extends RunCommand.Options {

package/esm/commands/publish-command.js

@@ -51,23 +51,20 @@ export class PublishCommand extends RunCommand {
         await Promise.all(promises);
         return super._prepareTasks(selectedPackages, { newVersions });
     }
-    async _exec(args, options) {
-        if (args.command === '#') {
-            if (args.name === 'root')
+    async _exec(pkg, command, args, options) {
+        if (command === '#') {
+            if (pkg === this.repository.rootPackage)
                 return { code: 0 };
             const cwd = this.options.contents
-                ? path.resolve(this.repository.dirname, path.join(this.options.contents, path.basename(args.cwd)))
-                : args.cwd;
-            return super._exec({
+                ? path.resolve(this.repository.dirname, path.join(this.options.contents, path.basename(pkg.dirname)))
+                : pkg.dirname;
+            return super._exec(pkg, 'npm publish' + (this.options.access ? ' --access=' + this.options.access : ''), {
                 ...args,
                 cwd,
-                command: 'npm publish' + (this.options.access ? ' --access=' + this.options.access : '')
-            }, {
-                ...options,
-                stdio: logger.levelIndex < 1000 ? 'inherit' : 'pipe'
-            });
+                stdio: logger.levelIndex < 1000 ? 'inherit' : 'pipe',
+            }, options);
         }
-        return super._exec(args, options);
+        return super._exec(pkg, command, args, options);
     }
 }
 PublishCommand.commandName = 'publish';

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

@@ -10,18 +10,10 @@ export declare class RunCommand<TOptions extends RunCommand.Options> extends Mul
     static commandName: string;
     constructor(repository: Repository, script: string, options?: TOptions);
     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;
+    protected _prepareScriptTask(pkg: Package, options?: any): Task | undefined;
+    protected _exec(pkg: Package, command: string, args: {
         stdio?: 'inherit' | 'pipe';
+        cwd?: string;
         json?: any;
         logLevel?: string;
         noThrow?: boolean;

package/esm/commands/run-command.js

@@ -15,22 +15,13 @@ export class RunCommand extends MultiTaskCommand {
         const packageTasks = [];
         for (const p of packages) {
             if (p.json.scripts) {
-                const childTask = this._prepareScriptTask({
-                    name: p.name,
-                    cwd: p.dirname,
-                    json: p.json,
-                    dependencies: p.dependencies
-                }, options);
+                const childTask = this._prepareScriptTask(p, options);
                 if (childTask) {
                     packageTasks.push(childTask);
                 }
             }
         }
-        const rootTask = this._prepareScriptTask({
-            name: 'root',
-            cwd: this.repository.dirname,
-            json: this.repository.json
-        });
+        const rootTask = this._prepareScriptTask(this.repository.rootPackage);
         if (!rootTask?.children)
             return packageTasks;
         const tasks = [];
@@ -43,57 +34,51 @@ export class RunCommand extends MultiTaskCommand {
         tasks.push(...post);
         return tasks;
     }
-    _prepareScriptTask(args, ctx) {
-        const json = { ...args.json };
+    _prepareScriptTask(pkg, options) {
+        const json = { ...pkg.json };
         json.scripts = json.scripts || {};
         json.scripts[this.script] = json.scripts[this.script] || '#';
-        let scriptInfo;
-        try {
-            scriptInfo = parseNpmScript(json, 'npm run ' + this.script);
-            if (!(scriptInfo && scriptInfo.raw))
-                return;
-        }
-        catch {
+        const scriptInfo = parseNpmScript(json, 'npm run ' + this.script);
+        if (!(scriptInfo && scriptInfo.raw))
             return;
-        }
         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({
-                        ...args,
-                        command: cmd,
+                    return await this._exec(pkg, cmd, {
                         stdio: logger.levelIndex < 1000 ? 'inherit' : 'pipe'
-                    }, ctx);
+                    }, options);
                 }, {
-                    name: args.name + ':' + s.name,
+                    name: pkg.name + ':' + s.name,
                     dependencies: (this.options.parallel || s.name.startsWith('pre') || s.name.startsWith('post')) ?
-                        undefined : args.dependencies
+                        undefined : pkg.dependencies
                 });
                 children.push(task);
             }
         }
         if (children.length) {
             return new Task(children, {
-                name: args.name,
+                name: pkg.name,
                 bail: true,
                 serial: true,
             });
         }
     }
-    async _exec(args, options) {
+    async _exec(pkg, command, args, options) {
+        const name = pkg === this.repository.rootPackage ? 'root' : pkg.name;
         const logLevel = args.logLevel == null ? 'info' : args.logLevel;
         if (logLevel)
-            logger.verbose(this.commandName, chalk.cyan(args.name), chalk.cyanBright.bold('executing'), logger.separator, args.command);
+            logger.verbose(this.commandName, chalk.cyan(name), chalk.cyanBright.bold('executing'), logger.separator, command);
         const t = Date.now();
-        const r = await exec(args.command, { cwd: args.cwd, stdio: args.stdio, throwOnError: false });
+        const cwd = args.cwd || pkg.dirname;
+        const r = await exec(command, { cwd, stdio: args.stdio, throwOnError: false });
         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() + ('\n' + r.stdout).trim());
+                logger.error(this.commandName, chalk.cyan(name), chalk.red.bold('failed'), logger.separator, command, logger.separator, r.error.message.trim() + ('\n' + r.stdout).trim());
             }
             else
-                logger.log(logLevel, this.commandName, chalk.cyan(args.name), chalk.green.bold('executed'), logger.separator, args.command, chalk.yellow(' (' + (Date.now() - t) + ' ms)'));
+                logger.log(logLevel, this.commandName, chalk.cyan(name), chalk.green.bold('executed'), logger.separator, command, chalk.yellow(' (' + (Date.now() - t) + ' ms)'));
         if (r.error && !args.noThrow)
             throw r.error;
         return r;

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

@@ -8,15 +8,10 @@ export declare class VersionCommand extends RunCommand<VersionCommand.Options> {
     readonly repository: Repository;
     bump: string;
     static commandName: string;
+    private _updatedPackages;
     constructor(repository: Repository, bump: string, options?: VersionCommand.Options);
     protected _prepareTasks(packages: Package[]): Promise<Task[]>;
-    protected _exec(args: {
-        name: string;
-        json: any;
-        cwd: string;
-        dependencies?: string[];
-        command: string;
-    }, options?: any): Promise<ExecuteCommandResult>;
+    protected _exec(pkg: Package, command: string, args: {}, options?: any): Promise<ExecuteCommandResult>;
 }
 export declare namespace VersionCommand {
     interface Options extends RunCommand.Options {

package/esm/commands/version-command.js

@@ -1,5 +1,4 @@
 import chalk from 'chalk';
-import fs from 'fs/promises';
 import logger from 'npmlog';
 import path from 'path';
 import { Task } from 'power-tasks';
@@ -13,6 +12,7 @@ export class VersionCommand extends RunCommand {
         super(repository, 'version', options);
         this.repository = repository;
         this.bump = bump;
+        this._updatedPackages = new Set();
     }
     async _prepareTasks(packages) {
         const { repository } = this;
@@ -22,6 +22,7 @@ export class VersionCommand extends RunCommand {
         const newVersions = {};
         let errorCount = 0;
         const selectedPackages = [];
+        const dependentPackages = [];
         for (const p of packages) {
             const relDir = path.relative(repository.dirname, p.dirname);
             let status = '';
@@ -63,6 +64,10 @@ export class VersionCommand extends RunCommand {
                 continue;
             }
             selectedPackages.push(p);
+            packages.forEach(p2 => {
+                if (p2.dependencies.includes(p.name) && !dependentPackages.includes(p2))
+                    dependentPackages.push(p2);
+            });
         }
         if (errorCount)
             throw new Error('Unable to bump version due to error(s)');
@@ -72,50 +77,74 @@ export class VersionCommand extends RunCommand {
         if (this.options.unified) {
             Object.keys(newVersions).forEach(k => newVersions[k] = maxVer);
         }
+        dependentPackages.forEach(p2 => {
+            if (!selectedPackages.includes(p2))
+                selectedPackages.push(p2);
+        });
         const tasks = await super._prepareTasks(selectedPackages, { newVersions });
         tasks.forEach(t => t.options.exclusive = true);
-        if (this.options.unified)
+        if (!this.options.noTag) {
             tasks.push(new Task(async () => {
-                try {
-                    await super._exec({
-                        name: 'rman',
-                        command: 'git tag -a "v' + maxVer + '" -m "version ' + maxVer + '"',
-                        cwd: this.repository.dirname,
+                while (this._updatedPackages.size) {
+                    const filenames = [];
+                    const [first] = this._updatedPackages;
+                    for (const pkg of this._updatedPackages) {
+                        if (pkg.version === first.version) {
+                            filenames.push(path.relative(this.repository.rootPackage.dirname, pkg.jsonFileName));
+                            this._updatedPackages.delete(pkg);
+                        }
+                    }
+                    await super._exec(this.repository.rootPackage, 'git commit -m "' + first.version + '" ' + filenames.map(s => '"' + s + '"').join(' '), {
                         stdio: logger.levelIndex < 1000 ? 'inherit' : 'pipe',
                         logLevel: 'silly'
                     });
                 }
-                catch {
-                    //
-                }
+                if (this.options.unified)
+                    try {
+                        await super._exec(this.repository.rootPackage, '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(args, options) {
-        if (args.name === 'root')
+    async _exec(pkg, command, args, options) {
+        if (pkg === this.repository.rootPackage)
             return { code: 0 };
-        if (args.command === '#') {
+        if (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'
-                });
+            pkg.reloadJson();
+            const oldVer = pkg.json.version;
+            const newVer = newVersions[pkg.name];
+            pkg.json.version = newVer;
+            delete pkg.json.scripts.version;
+            pkg.writeJson();
+            if (!this._updatedPackages.has(pkg))
+                this._updatedPackages.add(pkg);
+            const packages = this.repository.getPackages();
+            for (const p of packages) {
+                if (p.dependencies.includes(pkg.name)) {
+                    p.reloadJson();
+                    for (const k of ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']) {
+                        if (p.json[k]?.[pkg.name]) {
+                            p.json[k][pkg.name] = '^' + newVer;
+                        }
+                    }
+                    p.writeJson();
+                    if (!this._updatedPackages.has(p))
+                        this._updatedPackages.add(p);
+                }
             }
-            logger.info(this.commandName, args.name, logger.separator, 'Version changed from ' + chalk.cyan(oldVer) + ' to ' + chalk.cyan(newVer));
+            logger.info(this.commandName, pkg.name, logger.separator, 'Version changed from ' + chalk.cyan(oldVer) + ' to ' + chalk.cyan(newVer));
             return { code: 0 };
         }
-        return super._exec(args, options);
+        return super._exec(pkg, command, args, options);
     }
 }
 VersionCommand.commandName = 'version';

package/esm/core/package.d.ts

@@ -6,6 +6,8 @@ export declare class Package {
     get name(): string;
     get version(): string;
     get json(): any;
+    get jsonFileName(): string;
     get isPrivate(): boolean;
     reloadJson(): any;
+    writeJson(): void;
 }

package/esm/core/package.js

@@ -15,12 +15,20 @@ export class Package {
     get json() {
         return this._json;
     }
+    get jsonFileName() {
+        return path.join(this.dirname, 'package.json');
+    }
     get isPrivate() {
         return !!this._json.private;
     }
     reloadJson() {
-        const f = path.join(this.dirname, 'package.json');
+        const f = this.jsonFileName;
         this._json = JSON.parse(fs.readFileSync(f, 'utf-8'));
         return this._json;
     }
+    writeJson() {
+        const f = this.jsonFileName;
+        const data = JSON.stringify(this._json, undefined, 2);
+        fs.writeFileSync(f, data, 'utf-8');
+    }
 }

package/esm/core/repository.d.ts

@@ -3,6 +3,7 @@ export declare class Repository extends Package {
     readonly dirname: string;
     readonly config: any;
     readonly packages: Package[];
+    readonly rootPackage: Package;
     protected constructor(dirname: string, config: any, packages: Package[]);
     getPackages(options?: {
         scope?: string | string[];

package/esm/core/repository.js

@@ -11,6 +11,7 @@ export class Repository extends Package {
         this.dirname = dirname;
         this.config = config;
         this.packages = packages;
+        this.rootPackage = new Package(dirname);
     }
     getPackages(options) {
         const result = [...this.packages];

package/esm/utils/exec.js

@@ -12,6 +12,8 @@ export async function exec(command, options) {
         ...npmRunPathEnv({ cwd: opts.cwd }),
         ...opts.env
     };
+    if (process.env.TS_NODE_PROJECT)
+        delete opts.env.TS_NODE_PROJECT;
     opts.cwd = opts.cwd || process.cwd();
     const spawnOptions = {
         stdio: opts.stdio || 'pipe',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Monorepo repository manager",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "author": "Panates",
   "license": "MIT",
   "contributors": [