rman 0.38.0 → 1.0.2

package/commands/ci.command.js

@@ -0,0 +1,30 @@
+import { CiService } from '../services/ci.service.js';
+import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
+import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'ci',
+        describe: 'Deletes node_modules and lockfiles in every package, then reinstalls from scratch',
+        builder: cmd => applyBranchGuardOptions(applyPackageFilterOptions(cmd))
+            .example('$0 ci', '')
+            .option('package-manager', {
+            describe: 'Package manager to install with (default: npm, or .rmanrc "packageManager")',
+            choices: PACKAGE_MANAGERS,
+        })
+            .option('progress', {
+            describe: 'Show a live progress panel while running (default: true; auto-disabled when not a TTY). ' +
+                'Unlike run/build, completion is not reported as a per-package tally - only failures are called out.',
+            type: 'boolean',
+        }),
+        handler: async (args) => {
+            await assertAllowedBranch(repository, readBranchGuardOptions(args));
+            await CiService.reinstall(repository, {
+                ...readPackageFilterOptions(args),
+                packageManager: args.packageManager,
+                progress: args.progress,
+                logLevel: args.logLevel,
+            });
+        },
+    });
+}
+const PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm', 'bun'];

package/commands/clean.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/clean.command.js

@@ -0,0 +1,36 @@
+import { CleanService } from '../services/clean.service.js';
+import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
+import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'clean',
+        describe: 'Removes compiled TypeScript output and any extra files/dirs configured via .rmanrc "clean"',
+        builder: cmd => applyBranchGuardOptions(applyPackageFilterOptions(cmd))
+            .example('$0 clean', '')
+            .example('$0 clean --dry-run', '# Preview what would be removed')
+            .option('progress', {
+            describe: 'Show a live progress panel (default: true; auto-disabled when not a TTY)',
+            type: 'boolean',
+        })
+            .option('dry-run', {
+            describe: 'Report what would be removed without actually removing anything',
+            type: 'boolean',
+        })
+            .option('root', {
+            alias: 'r',
+            describe: 'Clean the whole repository even when the current directory is inside a single ' +
+                'package (which otherwise scopes cleaning to just that package). No effect elsewhere.',
+            type: 'boolean',
+        }),
+        handler: async (args) => {
+            await assertAllowedBranch(repository, readBranchGuardOptions(args));
+            await CleanService.clean(repository, {
+                ...readPackageFilterOptions(args),
+                progress: args.progress,
+                dryRun: args.dryRun,
+                root: args.root,
+                logLevel: args.logLevel,
+            });
+        },
+    });
+}

package/commands/diff.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/diff.command.js

@@ -0,0 +1,51 @@
+import path from 'node:path';
+import colors from 'ansi-colors';
+import { findLatestTag } from '../utils/change-hash.js';
+import { GitHelper } from '../utils/git.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'diff [package]',
+        describe: "Shows the git diff since a package's (or the whole repository's) last release tag",
+        builder: cmd => cmd
+            .example('$0 diff', "# Since the repository's own last tag")
+            .example('$0 diff pkg-a', "# Since pkg-a's own last tag, scoped to its directory")
+            .positional('package', {
+            describe: 'Package name - diffs just that package, since its own last tag. Omit to diff the whole ' +
+                "repository since its own last tag (or the current directory's package, if standing inside one).",
+            type: 'string',
+        }),
+        handler: async (args) => {
+            const git = new GitHelper({ cwd: repository.dirname });
+            const packageName = args.package;
+            let target = repository.rootPackage;
+            let pathspec;
+            if (packageName) {
+                const pkg = repository.getPackage(packageName);
+                if (!pkg) {
+                    const message = `No such package "${packageName}"`;
+                    console.log(colors.red(message));
+                    const err = new Error(message);
+                    err.logged = true;
+                    throw err;
+                }
+                target = pkg;
+                pathspec = path.relative(repository.dirname, pkg.dirname);
+            }
+            else if (repository.currentPackage) {
+                target = repository.currentPackage;
+                pathspec = path.relative(repository.dirname, target.dirname);
+            }
+            const tag = await findLatestTag(git, target);
+            if (!tag) {
+                console.log(colors.gray(`No release tag found for "${target.name}" - nothing to diff against.`));
+                return;
+            }
+            const text = await git.diff(tag, pathspec);
+            if (!text.trim()) {
+                console.log(colors.gray(`No changes since ${tag}.`));
+                return;
+            }
+            console.log(text);
+        },
+    });
+}

package/commands/exec.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/exec.command.js

@@ -0,0 +1,83 @@
+import { ExecService } from '../services/exec.service.js';
+import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
+import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'exec [command..]',
+        describe: 'Runs an arbitrary shell command in each package - unlike run, not tied to any npm script',
+        builder: cmd => applyBranchGuardOptions(applyPackageFilterOptions(cmd))
+            .parserConfiguration({ 'populate--': true, 'unknown-options-as-args': true })
+            .example('$0 exec rm -rf dist', '# Not an npm script - runs directly in every package')
+            .example('$0 exec --scope pkg-a -- ls -la', '# "--" needed only if the command shares a flag name with exec\'s own')
+            .positional('command', {
+            describe: "The command (and its own arguments) to run in each package - its own flags don't need to be " +
+                'escaped unless one happens to share a name with one of these options below, in which case put ' +
+                '"--" first',
+            type: 'string',
+        })
+            .option('parallel', {
+            describe: 'Max packages at once: omit/true for CPU count, a number for that many, false to run serially. ' +
+                'Packages always run in dependency order unless --no-topo.',
+            coerce: (v) => {
+                if (v === undefined)
+                    return undefined;
+                if (v === 'false' || v === false)
+                    return false;
+                if (v === 'true' || v === true)
+                    return true;
+                const n = Number(v);
+                return Number.isFinite(n) ? n : true;
+            },
+        })
+            .option('bail', {
+            describe: 'Stop on first failure (default: true)',
+            type: 'boolean',
+        })
+            .option('topo', {
+            describe: 'Respect package dependency order: a package waits for its dependencies and is skipped if one ' +
+                'fails. Set false to run in every matching package independently, alphabetically. Default: true.',
+            type: 'boolean',
+        })
+            .option('progress', {
+            describe: 'Show a live progress panel (default: true; auto-disabled when not a TTY)',
+            type: 'boolean',
+        })
+            .option('changed', {
+            alias: 'c',
+            describe: 'Only run in packages that have changed since the last publish',
+            type: 'boolean',
+        })
+            .option('changed-since', {
+            describe: 'Only run in packages that have changed since the given git commit/hash',
+            type: 'string',
+        })
+            .option('root', {
+            alias: 'r',
+            describe: 'Run across the whole repository even when the current directory is inside a single ' +
+                'package (which otherwise scopes the run to just that package). No effect elsewhere.',
+            type: 'boolean',
+        })
+            .conflicts('changed', 'changed-since'),
+        handler: async (args) => {
+            await assertAllowedBranch(repository, readBranchGuardOptions(args));
+            const afterDashDash = args['--'];
+            const tokens = afterDashDash?.length ? afterDashDash : args.command;
+            if (!tokens?.length) {
+                const err = new Error('No command given - e.g. "rman exec ls" or "rman exec -- eslint --bail"');
+                throw err;
+            }
+            const command = tokens.join(' ');
+            await ExecService.exec(repository, command, {
+                ...readPackageFilterOptions(args),
+                parallel: args.parallel,
+                topo: args.topo,
+                bail: args.bail,
+                progress: args.progress,
+                changed: args.changed,
+                changedSince: args.changedSince,
+                logLevel: args.logLevel,
+                root: args.root,
+            });
+        },
+    });
+}

package/commands/import.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/import.command.js

@@ -0,0 +1,27 @@
+import path from 'node:path';
+import colors from 'ansi-colors';
+import { ImportService } from '../services/import.service.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'import <path>',
+        describe: 'Imports an external git repository as a new package, preserving its full commit history',
+        builder: cmd => cmd
+            .example('$0 import ../my-old-repo', '')
+            .example('$0 import ../my-old-repo --dest libs', '# Under libs/ instead of packages/')
+            .positional('path', {
+            describe: 'Path to a local clone of the repository to import (not a URL - clone it first)',
+            type: 'string',
+        })
+            .option('dest', {
+            describe: 'Subdirectory the new package is placed under (default: "packages")',
+            type: 'string',
+        }),
+        handler: async (args) => {
+            const result = await ImportService.importRepo(repository, args.path, {
+                dest: args.dest,
+            });
+            console.log(colors.green('imported'), colors.cyan(result.name), '->', path.relative(repository.dirname, result.targetDir), colors.gray(`(${result.commitCount} commit(s))`));
+            console.log(colors.gray('Add it to your workspaces glob if it is not already covered, then reinstall ("ci").'));
+        },
+    });
+}

package/commands/info.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/info.command.js

@@ -0,0 +1,61 @@
+import colors from 'ansi-colors';
+import semver from 'semver';
+import { SystemInfo } from '../services/system-info.js';
+function printSystemInfo(systemInfo) {
+    const maxName = Object.keys(systemInfo).reduce((l, p) => Object.keys(systemInfo[p]).reduce((i, x) => Math.max(i, x.length), l), 0);
+    for (const [categoryName, category] of Object.entries(systemInfo)) {
+        console.log('', colors.whiteBright(categoryName) + ':');
+        for (const [n, v] of Object.entries(category)) {
+            const label = '    ' + colors.reset(n) + ' '.repeat(maxName - n.length) + ' :';
+            if (typeof v === 'string') {
+                console.log(label, colors.yellowBright(v));
+                continue;
+            }
+            if (v.version) {
+                console.log(label, colors.yellowBright(v.version), v.path ? ' ' + colors.yellow(v.path) : '');
+            }
+            if (v.installed) {
+                if (v.wanted === 'latest' || semver.intersects(v.installed, v.wanted)) {
+                    console.log(label, colors.yellowBright(v.installed));
+                }
+                else {
+                    console.log(label, colors.red(v.installed), ' => ', colors.yellowBright(v.wanted));
+                }
+            }
+        }
+    }
+}
+function printRepositoryInfo(info) {
+    console.log('', colors.whiteBright('Repository') + ':');
+    console.log('    ' + colors.reset('Type') + '     :', colors.yellowBright(info.type === 'monorepo' ? 'Monorepo' : 'Single package'));
+    console.log('    ' + colors.reset('Name') + '     :', colors.yellowBright(info.name || '(none)'));
+    console.log('    ' + colors.reset('Version') + '  :', colors.yellowBright(info.version || '(none)'));
+    console.log('    ' + colors.reset('Root') + '     :', colors.yellowBright(info.root));
+    if (info.type === 'monorepo') {
+        console.log('    ' + colors.reset('Packages') + ' :', colors.yellowBright(String(info.packageCount)), colors.gray('(run "list" to see them)'));
+    }
+}
+export function initCli(repository, program) {
+    program.command({
+        command: 'info',
+        describe: 'Prints local environment and repository information',
+        builder: cmd => cmd
+            .example('$0 info', '# Prints information')
+            .example('$0 info --json', '# Prints information in JSON format')
+            .option('json', {
+            alias: 'j',
+            describe: 'Print output as JSON',
+            type: 'boolean',
+        }),
+        handler: async (args) => {
+            const systemInfo = await SystemInfo.getSystemInfo();
+            const repositoryInfo = SystemInfo.getRepositoryInfo(repository);
+            if (args.json) {
+                console.log(JSON.stringify({ ...systemInfo, repository: repositoryInfo }, undefined, 2));
+                return;
+            }
+            printSystemInfo(systemInfo);
+            printRepositoryInfo(repositoryInfo);
+        },
+    });
+}

package/commands/list.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/list.command.js

@@ -0,0 +1,113 @@
+import colors from 'ansi-colors';
+import EasyTable from 'easy-table';
+import { ListService } from '../services/list.service.js';
+import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+function statusLabel(status) {
+    switch (status) {
+        case 'dirty':
+            return colors.magenta('dirty');
+        case 'committed':
+            return colors.yellow('committed');
+        case 'changed':
+            return colors.cyan('changed');
+        default:
+            return '';
+    }
+}
+function printTable(items) {
+    const table = new EasyTable();
+    for (const it of items) {
+        table.cell('Package', colors.yellowBright(it.name));
+        table.cell('Version', colors.yellow(it.version));
+        table.cell('Private', it.private ? colors.magentaBright('yes') : '');
+        table.cell('Changed', statusLabel(it.status));
+        table.cell('Path', it.location);
+        table.newRow();
+    }
+    console.log(table.toString().trim());
+    console.log('');
+    console.log(colors.gray(`${items.length} Package(s) found`));
+}
+function printParseable(items) {
+    for (const it of items) {
+        console.log([
+            it.location,
+            it.name,
+            it.version,
+            it.private ? 'PRIVATE' : '',
+            it.status !== 'clean' ? it.status.toUpperCase() : '',
+        ].join('::'));
+    }
+}
+function printGraph(items) {
+    const graph = {};
+    for (const it of items)
+        graph[it.name] = it.dependencies;
+    console.log(JSON.stringify(graph, undefined, 2));
+}
+export function initCli(repository, program) {
+    program.command({
+        command: 'list [options...]',
+        aliases: ['ls'],
+        describe: 'Lists packages in repository',
+        builder: cmd => applyPackageFilterOptions(cmd)
+            .example('$0 list', '# List all packages')
+            .example('$0 list --json', '# List all packages in JSON format')
+            .conflicts('graph', ['parseable', 'json'])
+            .conflicts('short', ['parseable', 'json'])
+            .conflicts('changed', 'changed-since')
+            .option('short', {
+            alias: 's',
+            describe: 'Do not show extended information',
+            type: 'boolean',
+        })
+            .option('parseable', {
+            alias: 'p',
+            describe: 'Show parseable output',
+            type: 'boolean',
+        })
+            .option('toposort', {
+            alias: 't',
+            describe: 'Sort packages in topological order (dependencies before dependents) instead of lexical by directory',
+            type: 'boolean',
+        })
+            .option('graph', {
+            alias: 'g',
+            describe: 'Show dependency graph as a JSON-formatted adjacency list',
+            type: 'boolean',
+        })
+            .option('json', {
+            alias: 'j',
+            describe: 'Show output in JSON format',
+            type: 'boolean',
+        })
+            .option('changed', {
+            alias: 'c',
+            describe: 'Only list packages that have changed since the last publish (dirty or committed but not yet published)',
+            type: 'boolean',
+        })
+            .option('changed-since', {
+            describe: 'Only list packages that have changed since the given git commit/hash',
+            type: 'string',
+        }),
+        handler: async (args) => {
+            const items = await ListService.getPackages(repository, {
+                ...readPackageFilterOptions(args),
+                toposort: args.toposort,
+                changed: args.changed,
+                changedSince: args.changedSince,
+            });
+            if (args.graph)
+                printGraph(items);
+            else if (args.json)
+                console.log(JSON.stringify(items, undefined, 2));
+            else if (args.parseable)
+                printParseable(items);
+            else if (args.short)
+                for (const it of items)
+                    console.log(it.name);
+            else
+                printTable(items);
+        },
+    });
+}

package/commands/publish.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/publish.command.js

@@ -0,0 +1,147 @@
+import readline from 'node:readline/promises';
+import colors from 'ansi-colors';
+import { CiService } from '../services/ci.service.js';
+import { PublishService } from '../services/publish.service.js';
+import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
+import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'publish',
+        describe: 'Publishes every non-private package whose local version is not already on the registry',
+        builder: cmd => applyBranchGuardOptions(applyPackageFilterOptions(cmd))
+            .example('$0 publish', '# Show the plan, then ask for confirmation')
+            .example('$0 publish --yes', '# Publish immediately, no confirmation')
+            .example('$0 publish --dry-run', '# Only show the plan, never publish')
+            .option('yes', {
+            alias: 'y',
+            describe: 'Skip the confirmation prompt and publish immediately',
+            type: 'boolean',
+        })
+            .option('dry-run', {
+            describe: 'Only show the plan - never publishes, regardless of --yes',
+            type: 'boolean',
+        })
+            .option('ignore-dirty', {
+            describe: 'Exclude a package with uncommitted local changes instead of aborting the whole run',
+            type: 'boolean',
+        })
+            .option('package-manager', {
+            describe: 'Package manager to publish with (default: npm, or .rmanrc "packageManager")',
+            choices: PACKAGE_MANAGERS,
+        })
+            .option('access', {
+            describe: 'npm publish --access <public|restricted> - required by the registry for a new scoped package',
+            choices: ['public', 'restricted'],
+        })
+            .option('tag', {
+            describe: 'npm publish --tag <tag> - the dist-tag this version is published under (default "latest")',
+            type: 'string',
+        })
+            .option('otp', {
+            describe: 'npm publish --otp <otp> - a 2FA one-time password, for registries that require it',
+            type: 'string',
+        })
+            .option('registry', {
+            describe: 'Registry to check against and publish to (default: whatever .npmrc already configures)',
+            type: 'string',
+        })
+            .option('userconfig', {
+            describe: 'Path to a custom .npmrc to use for both the registry check and the actual publish',
+            type: 'string',
+        })
+            .option('contents', {
+            describe: "Subdirectory to publish from, relative to each package's own directory - only consulted when a " +
+                'package has no "publishConfig.directory" of its own (that always wins when present)',
+            type: 'string',
+        }),
+        handler: async (args) => {
+            await assertAllowedBranch(repository, readBranchGuardOptions(args));
+            const options = {
+                ...readPackageFilterOptions(args),
+                ignoreDirty: args.ignoreDirty,
+                registry: args.registry,
+                userconfig: args.userconfig,
+            };
+            const plan = await PublishService.getPlan(repository, options);
+            printPlan(plan);
+            const errors = plan.filter(e => e.status === 'error');
+            if (errors.length) {
+                const message = `${errors.length} package(s) have uncommitted local changes ` +
+                    '(pass --ignore-dirty to exclude them instead of aborting)';
+                console.log(colors.red(message));
+                const err = new Error(message);
+                err.logged = true;
+                throw err;
+            }
+            if (!plan.some(e => e.status === 'publish')) {
+                console.log(colors.gray('Nothing to publish.'));
+                return;
+            }
+            if (args.dryRun)
+                return;
+            let proceed = !!args.yes;
+            if (!proceed) {
+                if (!process.stdout.isTTY) {
+                    console.log(colors.gray('Not a TTY - refusing to prompt. Pass --yes to publish non-interactively.'));
+                    return;
+                }
+                proceed = await confirm('Publish these packages?');
+            }
+            if (!proceed)
+                return;
+            const applied = await PublishService.applyPlan(repository, plan, {
+                ...options,
+                packageManager: args.packageManager,
+                access: args.access,
+                tag: args.tag,
+                otp: args.otp,
+                contents: args.contents,
+            });
+            let failed = false;
+            for (const entry of applied) {
+                if (entry.status === 'publish') {
+                    console.log(colors.green('published'), colors.cyan(entry.package.name), entry.version);
+                }
+                else if (entry.status === 'error' && plan.find(e => e.package === entry.package)?.status === 'publish') {
+                    failed = true;
+                    console.log(colors.red('failed'), colors.cyan(entry.package.name), colors.red(entry.reason ?? ''));
+                }
+            }
+            if (failed) {
+                const err = new Error('"publish" failed');
+                err.logged = true;
+                throw err;
+            }
+        },
+    });
+}
+function printPlan(entries) {
+    for (const e of entries) {
+        const name = colors.cyan(e.package.name);
+        switch (e.status) {
+            case 'publish':
+                console.log(colors.green('publish'), name, e.version, colors.gray(e.reason ?? ''));
+                break;
+            case 'up-to-date':
+                console.log(colors.gray('up-to-date'), name, e.version);
+                break;
+            case 'skip':
+                console.log(colors.cyan('skip'), name, colors.gray(e.reason ?? ''));
+                break;
+            case 'error':
+                console.log(colors.red('error'), name, colors.red(e.reason ?? ''));
+                break;
+        }
+    }
+}
+async function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`${question} (y/N) `);
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}
+const PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm', 'bun'];

package/commands/run.command.d.ts

@@ -0,0 +1,6 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+import { RunService } from '../services/run.service.js';
+export declare function applyRunOptions<T>(cmd: Argv<T>): Argv<T>;
+export declare function readRunOptions(args: any): RunService.Options;
+export declare function initCli(repository: Repository, program: Argv): void;