rman 0.1.0 → 0.2.2

package/cjs/{workspace/executor.js → utils/exec.js}

@@ -3,28 +3,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeCommand = void 0;
+exports.exec = void 0;
 const child_process_1 = require("child_process");
-const npm_run_path_1 = __importDefault(require("npm-run-path"));
-const chalk_1 = __importDefault(require("chalk"));
-const utils_1 = require("./utils");
+const signal_exit_1 = __importDefault(require("signal-exit"));
+const npm_run_path_1 = require("./npm-run-path");
 const runningChildren = new Map();
-async function executeCommand(command, options) {
+async function exec(command, options) {
     const opts = {
-        ...options
+        shell: true,
+        throwOnError: true,
+        ...options,
     };
     opts.env = {
-        ...npm_run_path_1.default.env({ cwd: options?.cwd }),
-        //        FORCE_COLOR: `${chalk.level}`,
+        ...(0, npm_run_path_1.npmRunPathEnv)({ cwd: opts.cwd }),
         ...opts.env
     };
     opts.cwd = opts.cwd || process.cwd();
-    opts.color = opts.color == null ? true : opts.color;
     const spawnOptions = {
         stdio: opts.stdio || 'pipe',
         env: opts.env,
         cwd: opts.cwd,
-        shell: options?.shell,
+        shell: opts.shell,
         windowsHide: true
     };
     const result = {
@@ -69,7 +68,7 @@ async function executeCommand(command, options) {
         processData(data, 'stderr');
         processLines('stderr');
     });
-    return new Promise(resolve => {
+    return new Promise((resolve, reject) => {
         let resolved;
         child.on('error', (err) => {
             if (child.pid)
@@ -79,14 +78,16 @@ async function executeCommand(command, options) {
             if (resolved)
                 return;
             result.code = err.code || 1;
-            result.error = err;
-            if (!result.error) {
+            if (!err) {
                 const text = `Command failed (${result.code})`;
-                result.error =
-                    new Error((opts.color ? chalk_1.default.red(text) : text) + '\n  ' +
-                        opts.color ? chalk_1.default.white(err.message) : err.message);
+                err = new Error(text);
             }
+            if (typeof err === 'string')
+                err = new Error(err);
+            result.error = err;
             resolved = true;
+            if (opts.throwOnError)
+                return reject(result.error);
             resolve(result);
         });
         child.on('close', (code) => {
@@ -100,14 +101,14 @@ async function executeCommand(command, options) {
             resolved = true;
             if (code) {
                 const text = `Command failed (${result.code})`;
-                result.error = new Error((opts.color ? chalk_1.default.red(text) : text));
+                result.error = new Error(text);
             }
             return resolve(result);
         });
     });
 }
-exports.executeCommand = executeCommand;
-(0, utils_1.onProcessExit)(() => {
+exports.exec = exec;
+(0, signal_exit_1.default)(() => {
     runningChildren.forEach((child) => {
         child.kill();
     });

package/cjs/utils/git-utils.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitHelper = void 0;
+const exec_1 = require("./exec");
+const path_1 = __importDefault(require("path"));
+class GitHelper {
+    constructor(options) {
+        this.cwd = options?.cwd || process.cwd();
+    }
+    async listDirtyFileStatus(options) {
+        const x = await (0, exec_1.exec)('git', {
+            cwd: this.cwd,
+            argv: ['status', '--porcelain']
+        });
+        const result = [];
+        const files = x.stdout ? x.stdout.trim().split(/\s*\n\s*/) : [];
+        for (const f of files) {
+            const m = f.match(/^(\w+) (.+)$/);
+            if (m) {
+                result.push({
+                    filename: options?.absolute ? path_1.default.join(this.cwd, m[2]) : m[2],
+                    status: m[1]
+                });
+            }
+        }
+        return result;
+    }
+    async listDirtyFiles(options) {
+        return (await this.listDirtyFileStatus(options)).map(x => x.filename);
+    }
+    async listCommitSha() {
+        const x = await (0, exec_1.exec)('git', {
+            cwd: this.cwd,
+            argv: ['cherry']
+        });
+        const matches = x.stdout ? x.stdout.matchAll(/([a-f0-9]+)/gi) : [];
+        const result = [];
+        for (const m of matches) {
+            result.push(m[1]);
+        }
+        return result;
+    }
+    async listCommittedFiles(options) {
+        const shaArr = options?.commits
+            ? (Array.isArray(options?.commits) ? options?.commits : [options?.commits])
+            : await this.listCommitSha();
+        let result = [];
+        for (const s of shaArr) {
+            const x = await (0, exec_1.exec)('git', {
+                cwd: this.cwd,
+                argv: ['show', s, '--name-only', '--pretty="format:"']
+            });
+            result.push(...(x.stdout ? x.stdout.trim().split(/\s*\n\s*/) : []));
+        }
+        if (options?.absolute)
+            result = result.map(f => path_1.default.join(this.cwd, f));
+        return result;
+    }
+    async readFileLastPublished(filePath, commitSha) {
+        const x = await (0, exec_1.exec)('git', {
+            cwd: this.cwd,
+            argv: ['show', (commitSha || 'HEAD') + ':"' + filePath + '"']
+        });
+        return x.stdout || '';
+    }
+}
+exports.GitHelper = GitHelper;

package/cjs/utils/npm-run-path.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.npmRunPathEnv = exports.npmRunPath = void 0;
+/* eslint-disable max-len */
+/**
+ * Inspired from [npm-run-path](https://github.com/sindresorhus/npm-run-path)
+ */
+const process_1 = __importDefault(require("process"));
+const path_1 = __importDefault(require("path"));
+const path_key_1 = __importDefault(require("path-key"));
+/**
+ Get your [PATH](https://en.wikipedia.org/wiki/PATH_(variable)) prepended with locally installed binaries.
+ @returns The augmented path string.
+ @example
+ ```
+ import childProcess from 'node:child_process';
+ import {npmRunPath} from 'npm-run-path';
+ console.log(process.env.PATH);
+ //=> '/usr/local/bin'
+ console.log(npmRunPath());
+ //=> '/Users/sindresorhus/dev/foo/node_modules/.bin:/Users/sindresorhus/dev/node_modules/.bin:/Users/sindresorhus/node_modules/.bin:/Users/node_modules/.bin:/node_modules/.bin:/usr/local/bin'
+ ```
+ */
+function npmRunPath(options = {}) {
+    const cwd = options.cwd || process_1.default.cwd();
+    const path_ = options.path || process_1.default.env[(0, path_key_1.default)()];
+    const execPath = options.execPath || process_1.default.execPath;
+    let previous;
+    let cwdPath = path_1.default.resolve(cwd);
+    const result = [];
+    while (previous !== cwdPath) {
+        result.push(path_1.default.join(cwdPath, 'node_modules/.bin'));
+        previous = cwdPath;
+        cwdPath = path_1.default.resolve(cwdPath, '..');
+    }
+    // Ensure the running `node` binary is used.
+    result.push(path_1.default.resolve(cwd, execPath, '..'));
+    return [...result, path_].join(path_1.default.delimiter);
+}
+exports.npmRunPath = npmRunPath;
+/**
+ @returns The augmented [`process.env`](https://nodejs.org/api/process.html#process_process_env) object.
+ @example
+ ```
+ import childProcess from 'node:child_process';
+ import {npmRunPathEnv} from 'npm-run-path';
+ // `foo` is a locally installed binary
+ childProcess.execFileSync('foo', {
+    env: npmRunPathEnv()
+});
+ ```
+ */
+function npmRunPathEnv(options = {}) {
+    const env = { ...(options.env || process_1.default.env) };
+    const path_ = (0, path_key_1.default)({ env });
+    const opts = { ...options, path: env[path_] };
+    env[path_] = npmRunPath(opts);
+    return env;
+}
+exports.npmRunPathEnv = npmRunPathEnv;

package/cjs/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageJson = exports.getDirname = void 0;
+// noinspection ES6UnusedImports
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+function getDirname() {
+    const pst = Error.prepareStackTrace;
+    Error.prepareStackTrace = function (_, stack) {
+        Error.prepareStackTrace = pst;
+        return stack;
+    };
+    const e = new Error();
+    if (!e.stack)
+        throw Error('Can not parse stack');
+    const stack = e.stack.slice(1);
+    while (stack) {
+        const frame = stack.shift();
+        const filename = frame && frame.getFileName();
+        if (filename)
+            return path_1.default.dirname(filename).replace('file://', '');
+    }
+    throw Error('Can not parse stack');
+}
+exports.getDirname = getDirname;
+function getPackageJson(dirname) {
+    const f = path_1.default.resolve(dirname, 'package.json');
+    if (!fs_1.default.existsSync(f))
+        return;
+    return JSON.parse(fs_1.default.readFileSync(f, 'utf-8'));
+}
+exports.getPackageJson = getPackageJson;

package/esm/cli.d.ts

@@ -1 +1,4 @@
-export declare function run(argv?: string[]): Promise<void>;
+export declare function runCli(options?: {
+    argv?: string[];
+    cwd?: string;
+}): Promise<void>;

package/esm/cli.mjs

@@ -1,60 +1,50 @@
 import path from 'path';
 import fs from 'fs/promises';
+import yargs from "yargs";
 import chalk from 'chalk';
-import { program } from "commander";
-import { Workspace } from './workspace/workspace.mjs';
-import { URL } from 'url';
-export async function run(argv = process.argv) {
-    const pkgJson = JSON.parse(global.__dirname
-        ? await fs.readFile(path.resolve(__dirname, '../package.json'), 'utf-8')
-        // @ts-ignore
-        : await fs.readFile(new URL('../package.json', import.meta.url), 'utf-8'));
-    program.version(pkgJson.version || '');
-    program
-        .command('run <script>')
-        .description('Executes given script for every package in repository')
-        .action(async (script) => runScript(script))
-        .allowUnknownOption();
-    program
-        .command('build')
-        .description('Executes "build" script for every package in repository')
-        .action(async () => runScript('build'))
-        .allowUnknownOption();
-    program
-        .command('lint')
-        .description('Executes "lint" script for every package in repository')
-        .action(async () => runScript('lint'))
-        .allowUnknownOption();
-    program
-        .command('test')
-        .description('Executes "test" script for every package in repository')
-        .action(async () => runScript('lint'))
-        .allowUnknownOption();
-    program.parse(argv);
-}
-async function runScript(script) {
-    const workspace = Workspace.create();
-    const result = await workspace.runScript(script, {
-        gauge: true
-    });
-    if (!result.commands.length) {
-        console.warn(chalk.cyanBright('There is nothing to do for "') +
-            chalk.yellowBright(script) + chalk.cyanBright('" script.'));
-        return;
-    }
-    if (result.errorCount) {
-        console.error('\n' + chalk.yellow(result.errorCount) + chalk.white(' error(s)'));
-        let s = '';
-        for (let i = 0; i < result.commands.length; i++) {
-            const cmd = result.commands[i];
-            if (cmd.error) {
-                s += '\n' + (i + 1) + ') ' +
-                    chalk.cyanBright(cmd.package) + '\n' +
-                    chalk.white(cmd.command) + '\n' +
-                    chalk.red('Error: ' + cmd.error.message) + '\n' +
-                    chalk.red(cmd.stderr) + '\n';
-            }
-        }
-        console.error(s);
-    }
+import { getDirname } from './utils.mjs';
+import { Repository } from './core/repository.mjs';
+import { InfoCommand } from './commands/info-command.mjs';
+import { Command } from './core/command.mjs';
+import { ListCommand } from './commands/list-command.mjs';
+import { ChangedCommand } from './commands/changed-command.mjs';
+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';
+export async function runCli(options) {
+    const s = path.resolve(getDirname(), '../package.json');
+    const pkgJson = JSON.parse(await fs.readFile(s, 'utf-8'));
+    const repository = Repository.create(options?.cwd);
+    const _argv = options?.argv || process.argv.slice(2);
+    const globalKeys = Object.keys(Command.globalOptions).concat(["help", "version"]);
+    const program = yargs(_argv)
+        // .scriptName('rman')
+        .strict()
+        .version(pkgJson.version || '').alias('version', 'v')
+        .usage('$0 <cmd> [options...]')
+        .help('help').alias('help', 'h')
+        .showHelpOnFail(false, 'Run with --help for available options')
+        .fail((msg, err) => {
+        const text = (msg
+            ? msg + '\n\n' + chalk.whiteBright('Run with --help for available options')
+            : (err ? err.message : ''));
+        console.log('\n' + chalk.red(text));
+        throw msg;
+    })
+        // group options under "Global Options:" header
+        .options(Command.globalOptions)
+        .group(globalKeys, "Global Options:");
+    InfoCommand.initCli(repository, program);
+    ListCommand.initCli(repository, program);
+    ChangedCommand.initCli(repository, program);
+    ExecuteCommand.initCli(repository, program);
+    RunCommand.initCli(repository, program);
+    VersionCommand.initCli(repository, program);
+    PublishCommand.initCli(repository, program);
+    if (!_argv.length)
+        program.showHelp();
+    else
+        await program.parseAsync()
+            .catch(() => false);
 }

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

@@ -0,0 +1,16 @@
+import yargs from 'yargs';
+import { Repository } from '../core/repository';
+import { ListCommand } from './list-command';
+import { Package } from '../core/package';
+export declare class ChangedCommand extends ListCommand {
+    readonly repository: Repository;
+    static commandName: string;
+    constructor(repository: Repository, options?: ListCommand.Options);
+    protected _filter(pkg: Package, inf: {
+        isDirty?: boolean;
+        isCommitted?: boolean;
+    }): boolean;
+}
+export declare namespace ChangedCommand {
+    function initCli(repository: Repository, program: yargs.Argv): void;
+}

package/esm/commands/changed-command.mjs

@@ -0,0 +1,34 @@
+import { ListCommand } from './list-command.mjs';
+import { Command } from './../core/command.mjs';
+export class ChangedCommand extends ListCommand {
+    constructor(repository, options) {
+        super(repository, options);
+        this.repository = repository;
+    }
+    _filter(pkg, inf) {
+        if (!super._filter(pkg, inf))
+            return false;
+        return !!(inf.isDirty || inf.isCommitted);
+    }
+}
+ChangedCommand.commandName = 'changed';
+(function (ChangedCommand) {
+    function initCli(repository, program) {
+        program.command({
+            command: 'changed [options...]',
+            describe: 'List local packages that have changed since the last tagged release',
+            builder: (cmd) => {
+                return cmd
+                    .example("$0 changed", "# List changed packages")
+                    .example('$0 changed --json', '# List changed packages in JSON format')
+                    .option(ListCommand.cliCommandOptions);
+            },
+            handler: async (args) => {
+                const options = Command.composeOptions(ChangedCommand.commandName, args, repository.config);
+                await new ChangedCommand(repository, options)
+                    .execute();
+            }
+        });
+    }
+    ChangedCommand.initCli = initCli;
+})(ChangedCommand || (ChangedCommand = {}));

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

@@ -0,0 +1,18 @@
+import yargs from 'yargs';
+import { Repository } from '../core/repository';
+import { MultiTaskCommand } from './multi-task-command';
+import { Task } from 'power-tasks';
+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[];
+}
+export declare namespace ExecuteCommand {
+    interface Options extends MultiTaskCommand.Options {
+    }
+    const cliCommandOptions: Record<string, yargs.Options>;
+    function initCli(repository: Repository, program: yargs.Argv): void;
+}

package/esm/commands/execute-command.mjs

@@ -0,0 +1,72 @@
+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';
+import { Command } from './../core/command.mjs';
+export class ExecuteCommand extends MultiTaskCommand {
+    constructor(repository, cmd, argv, options) {
+        super(repository, options);
+        this.repository = repository;
+        this.cmd = cmd;
+        this.argv = argv;
+    }
+    _prepareTasks() {
+        const packages = this.repository.getPackages({ toposort: !this.options.parallel });
+        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(' ') || ''));
+                const r = await exec(this.cmd, {
+                    cwd: p.dirname,
+                    argv: this.argv
+                });
+                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'));
+            }, {
+                name: p.name,
+                dependencies: this.options.parallel ? undefined : p.dependencies,
+                bail: this.options.bail,
+                concurrency: this.options.concurrency
+            });
+            tasks.push(task);
+        }
+        return tasks;
+    }
+}
+ExecuteCommand.commandName = 'exec';
+(function (ExecuteCommand) {
+    ExecuteCommand.cliCommandOptions = {
+        ...MultiTaskCommand.cliCommandOptions
+    };
+    function initCli(repository, program) {
+        program.command({
+            command: 'exec [cmd] [args..]',
+            describe: 'Execute an arbitrary command in each package',
+            builder: (cmd) => {
+                return cmd
+                    .example("$0 exec -- ls", '')
+                    .example('$0 exec -- rm -rf ./node_modules', '')
+                    .parserConfiguration({
+                    "populate--": true,
+                })
+                    .positional("cmd", {
+                    describe: "The command to execute. Any command flags must be passed after --",
+                    type: "string",
+                })
+                    .positional("args", {
+                    describe: "Positional arguments to send to command",
+                    type: "string",
+                })
+                    .option(ExecuteCommand.cliCommandOptions);
+            },
+            handler: async (args) => {
+                const argv = args['--'] || [];
+                const options = Command.composeOptions(ExecuteCommand.commandName, args, repository.config);
+                await new ExecuteCommand(repository, '' + argv.shift(), argv, options).execute();
+            }
+        });
+    }
+    ExecuteCommand.initCli = initCli;
+})(ExecuteCommand || (ExecuteCommand = {}));

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

@@ -0,0 +1,10 @@
+import yargs from 'yargs';
+import { Command } from '../core/command';
+import { Repository } from '../core/repository';
+export declare class InfoCommand extends Command {
+    static commandName: string;
+    protected _execute(): Promise<any>;
+}
+export declare namespace InfoCommand {
+    function initCli(repository: Repository, program: yargs.Argv): void;
+}

package/esm/commands/info-command.mjs

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import envinfo from 'envinfo';
+import semver from 'semver';
+import { Command } from './../core/command.mjs';
+export class InfoCommand extends Command {
+    async _execute() {
+        const systemInfo = JSON.parse(await envinfo.run({
+            System: ['OS', 'CPU', 'Memory', 'Shell'],
+            Binaries: ['Node', 'Yarn', 'npm'],
+            Utilities: ['Git'],
+            npmPackages: ['rman', 'typescript'],
+            npmGlobalPackages: ['typescript']
+        }, { json: true }));
+        if (this.options.json) {
+            this.logger.output('', '%j', systemInfo);
+            return;
+        }
+        const maxName = Object.keys(systemInfo).reduce((l, p) => Object.keys(systemInfo[p]).reduce((i, x) => l = Math.max(i, x.length), l), 0);
+        for (const [categoryName, category] of Object.entries(systemInfo)) {
+            this.logger.output('', '', chalk.whiteBright(categoryName) + ':');
+            for (const [n, v] of Object.entries(category)) {
+                const label = '    ' + chalk.reset(n) +
+                    ' '.repeat(maxName - n.length) + ' :';
+                if (typeof v === 'string') {
+                    this.logger.output('', label, chalk.yellowBright(v));
+                    continue;
+                }
+                if (v.version)
+                    this.logger.output('', label, chalk.yellowBright(v.version), (v.path ? ' ' + chalk.yellow(v.path) : ''));
+                if (v.installed) {
+                    if (v.wanted === 'latest' || semver.intersects(v.installed, v.wanted))
+                        this.logger.output('', label, chalk.yellowBright(v.installed));
+                    else
+                        this.logger.output('', label, chalk.red(v.installed), ' => ', chalk.yellowBright(v.wanted));
+                }
+            }
+        }
+    }
+}
+InfoCommand.commandName = 'info';
+(function (InfoCommand) {
+    function initCli(repository, program) {
+        program.command({
+            command: 'info [options...]',
+            describe: 'Prints local environment information',
+            builder: (cmd) => {
+                return cmd
+                    .example("$0 info", "# Prints information")
+                    .example('$0 info --json', '# Prints information in JSON format');
+            },
+            handler: async (args) => {
+                const options = Command.composeOptions(InfoCommand.commandName, args, repository.config);
+                await new InfoCommand(options)
+                    .execute();
+            }
+        });
+    }
+    InfoCommand.initCli = initCli;
+})(InfoCommand || (InfoCommand = {}));

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

@@ -0,0 +1,38 @@
+import yargs from 'yargs';
+import EasyTable from 'easy-table';
+import { Command } from '../core/command';
+import { Repository } from '../core/repository';
+import { Package } from '../core/package';
+export declare class ListCommand<TOptions extends ListCommand.Options = ListCommand.Options> extends Command<TOptions> {
+    readonly repository: Repository;
+    static commandName: string;
+    onPrepare?(pkg: Package, data: ListCommand.PackageOutput): ListCommand.PackageOutput;
+    onPrintTable?(pkg: Package, data: ListCommand.PackageOutput, table: EasyTable): ListCommand.PackageOutput;
+    constructor(repository: Repository, options?: TOptions);
+    protected _filter(pkg: Package, inf: {
+        isDirty?: boolean;
+        isCommitted?: boolean;
+    }): boolean;
+    protected _execute(): Promise<any>;
+}
+export declare namespace ListCommand {
+    interface Options {
+        json?: boolean;
+        parseable?: boolean;
+        short?: boolean;
+        toposort?: boolean;
+        graph?: boolean;
+        changed?: boolean;
+        filter?: string | ((pkg: Package) => boolean);
+    }
+    interface PackageOutput {
+        name: string;
+        version?: string;
+        location?: string;
+        private?: boolean;
+        isDirty?: boolean;
+        isCommitted?: boolean;
+    }
+    const cliCommandOptions: Record<string, yargs.Options>;
+    function initCli(repository: Repository, program: yargs.Argv): void;
+}