rman 1.0.10 → 1.1.1

package/commands/changelog.command.js

@@ -1,19 +1,22 @@
 import colors from 'ansi-colors';
+import { ChangeHashService } from '../services/change-hash.service.js';
 import { ChangelogService } from '../services/changelog.service.js';
 import { Logger, resolveRootLogLevel } from '../utils/logger.js';
-import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+import { applyPackageFilterOptions, applyRootOption, readPackageFilterOptions } from '../utils/package-filter.js';
 export function initCli(repository, program) {
     program.command({
         command: 'changelog',
+        configKeys: ['changelog', 'publish.skip'],
         describe: 'Generates a changelog per package from unreleased commits',
-        builder: cmd => applyPackageFilterOptions(cmd)
+        builder: cmd => applyRootOption(applyPackageFilterOptions(cmd), 'Generate')
             .example('$0 changelog', "# Auto-detects each package's own last release tag (or npm version)")
             .example('$0 changelog --from <hash> --write', '# Since a specific commit, written to file')
             .option('from', {
             describe: 'Generate the changelog since this commit/hash, applied the same way to every package. ' +
-                'Default (also "npm" explicitly): auto-detect per package from its own most recent release ' +
-                'tag - same as "version"/"changed" - falling back to its published npm version (no tag yet), ' +
-                "then to its whole history for a package that's never been released at all",
+                'Default (also "auto" explicitly): auto-detect per package from its own most recent release ' +
+                'tag - same as "version"/"changed" - falling back to the version its own ecosystem\'s ' +
+                "registry reports (no tag yet), then to its whole history for a package that's never been " +
+                'released at all',
             type: 'string',
         })
             .option('write', {
@@ -24,12 +27,6 @@ export function initCli(repository, program) {
             describe: "With --write, the file to prepend into, relative to each package's own directory " +
                 '(default: "CHANGELOG.md", or .rmanrc "changelog.filePath")',
             type: 'string',
-        })
-            .option('root', {
-            alias: 'r',
-            describe: 'Generate for the whole repository even when the current directory is inside a single ' +
-                'package (which otherwise scopes it to just that package). No effect elsewhere.',
-            type: 'boolean',
         })
             .option('include-skipped', {
             describe: 'Also generate for a package with .rmanrc "publish.skip" - excluded by default',
@@ -46,10 +43,11 @@ export function initCli(repository, program) {
             const from = args.from;
             const write = args.write;
             const logger = new Logger(args.logLevel ?? resolveRootLogLevel(repository));
-            if (!from || from === 'npm') {
-                // Auto-detection is mostly local git work, but the npm fallback it can reach for (only
-                // when a package has no tag at all) is a network round trip per package - without this,
-                // the command looks hung for that stretch instead of just busy.
+            if (!from || from === ChangeHashService.AUTO) {
+                // Auto-detection is mostly local git work, but the registry fallback it can reach for
+                // (only when a package has no tag at all, and only if the package's own ecosystem provides
+                // one) is a network round trip per package - without this, the command looks hung for that
+                // stretch instead of just busy.
                 logger.info(colors.gray("Detecting each package's last release..."));
             }
             const options = {

package/commands/config.command.js

@@ -0,0 +1,60 @@
+import path from 'node:path';
+import colors from 'ansi-colors';
+import * as yaml from 'js-yaml';
+import { DEFERRED_PATHS } from '../core/config.js';
+import { applyRootOption, readRootOption } from '../utils/package-filter.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'config',
+        describe: 'Prints the effective .rmanrc config for the package of the current directory',
+        builder: cmd => applyRootOption(cmd, 'Print the config for')
+            .example('$0 config', '# The config of the package you are standing in')
+            .example('$0 config --root', "# The repository root's own config instead")
+            .example('$0 config --json | jq .version', '# Machine-readable')
+            .option('json', {
+            describe: 'Print as JSON instead of YAML - nothing else on stdout, so it can be piped.',
+            type: 'boolean',
+            default: false,
+        }),
+        handler: args => {
+            const target = (!readRootOption(args) && repository.currentPackage) || repository.rootPackage;
+            if (args.json) {
+                console.log(JSON.stringify(target.config, undefined, 2));
+                return;
+            }
+            /**
+             * **Colour only on a terminal, and here that is correctness rather than taste.** The header
+             * and notes are YAML `#` comments so the whole output stays loadable - and an escape sequence
+             * inside one makes it *unloadable*: `rman config > rmanrc.yml` wrote a file js-yaml rejects
+             * with "the stream contains non-printable characters" (measured; `ansi-colors` does not turn
+             * itself off for a pipe here). The repository's own convention for this is
+             * `process.stdout.isTTY`, as `run`/`exec`'s progress panel uses.
+             */
+            const comment = (text) => (process.stdout.isTTY ? colors.gray(text) : text);
+            const relativeDir = path.relative(repository.dirname, target.dirname) || '.';
+            console.log(comment(`# ${target.name} (${relativeDir})`));
+            for (const note of deferredNotes(target))
+                console.log(comment(`# ${note}`));
+            /** `noRefs`: a value appearing twice in the config is the *same object* after merging, and
+             *  js-yaml would otherwise emit the second as an `*anchor` reference - valid YAML that reads
+             *  as a mistake in something meant to be looked at. */
+            console.log(yaml.dump(target.config, { noRefs: true, lineWidth: 100 }).trimEnd());
+        },
+    });
+}
+/**
+ * The one honest caveat about this output: **`version.before`/`.exec`/`.after` are printed raw**,
+ * expressions and all, because they are the paths in `DEFERRED_PATHS` - `${{ pkg.targetVersion }}`
+ * cannot be evaluated until `version` has computed a plan, so the repository deliberately leaves
+ * them unevaluated at load. Without saying so, a reader sees an uninterpolated `${{ ... }}` sitting
+ * among interpolated values and concludes interpolation is broken.
+ */
+function deferredNotes(pkg) {
+    const raw = DEFERRED_PATHS.filter(p => valueAt(pkg.config, p) !== undefined);
+    if (!raw.length)
+        return [];
+    return [`${raw.join(', ')}: printed raw - evaluated by "version" itself, once it knows the target version`];
+}
+function valueAt(config, dotted) {
+    return dotted.split('.').reduce((node, key) => (node == null ? undefined : node[key]), config);
+}

package/commands/diff.command.js

@@ -1,14 +1,16 @@
 import path from 'node:path';
 import colors from 'ansi-colors';
-import { findLatestTag } from '../utils/change-hash.js';
+import { ChangeHashService } from '../services/change-hash.service.js';
 import { GitHelper } from '../utils/git.js';
+import { applyRootOption, readRootOption } from '../utils/package-filter.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
+        builder: cmd => applyRootOption(cmd, 'Diff')
             .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")
+            .example('$0 diff --root', '# The whole repository, from inside a package')
             .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).",
@@ -31,11 +33,14 @@ export function initCli(repository, program) {
                 target = pkg;
                 pathspec = path.relative(repository.dirname, pkg.dirname);
             }
-            else if (repository.currentPackage) {
+            else if (!readRootOption(args) && repository.currentPackage) {
+                /** The measured gap this closes: `diff` narrowed to the current package like `run` and
+                 *  `changelog` do, but offered no way to say "the whole repository" without naming a
+                 *  package - and no package name means the repository, so there was nothing to type. */
                 target = repository.currentPackage;
                 pathspec = path.relative(repository.dirname, target.dirname);
             }
-            const tag = await findLatestTag(git, target);
+            const tag = await ChangeHashService.findLatestTag(git, target);
             if (!tag) {
                 console.log(colors.gray(`No release tag found for "${target.name}" - nothing to diff against.`));
                 return;

package/commands/exec.command.js

@@ -1,11 +1,11 @@
 import { ExecService } from '../services/exec.service.js';
 import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
-import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+import { applyPackageFilterOptions, applyRootOption, 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))
+        builder: cmd => applyRootOption(applyBranchGuardOptions(applyPackageFilterOptions(cmd)), 'Run')
             .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')
@@ -50,12 +50,6 @@ export function initCli(repository, program) {
             .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) => {

package/commands/github-release.command.js

@@ -5,6 +5,7 @@ import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions }
 export function initCli(repository, program) {
     program.command({
         command: 'github-release',
+        configKeys: ['githubRelease', 'version.releaseTagPattern'],
         describe: "Creates the repository's GitHub Release for the version that just shipped",
         builder: cmd => applyBranchGuardOptions(cmd)
             .example('$0 github-release', '# Show what would be released, then ask for confirmation')

package/commands/info.command.d.ts

@@ -1,3 +1,12 @@
 import type { Argv } from 'yargs';
 import type { Repository } from '../core/repository.js';
+/**
+ * `rman info` - environment and repository, and back in the core because most of what it reports
+ * (OS, CPU, shell, git, the repository's own shape) is true of any repository.
+ *
+ * The Node half is not here at all: installing `rman-node` augments `SystemInfo` and the package
+ * manager, `npmPackages` and this plugin's own version start appearing. Without it nothing
+ * npm-shaped is asked for or printed, which is the right answer for a repository in any other
+ * language.
+ */
 export declare function initCli(repository: Repository, program: Argv): void;

package/commands/info.command.js

@@ -1,6 +1,5 @@
 import colors from 'ansi-colors';
 import semver from 'semver';
-import { CiService } from '../services/ci.service.js';
 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);
@@ -36,6 +35,15 @@ function printRepositoryInfo(info) {
         console.log('    ' + colors.reset('Packages') + ' :', colors.yellowBright(String(info.packageCount)), colors.gray('(run "list" to see them)'));
     }
 }
+/**
+ * `rman info` - environment and repository, and back in the core because most of what it reports
+ * (OS, CPU, shell, git, the repository's own shape) is true of any repository.
+ *
+ * The Node half is not here at all: installing `rman-node` augments `SystemInfo` and the package
+ * manager, `npmPackages` and this plugin's own version start appearing. Without it nothing
+ * npm-shaped is asked for or printed, which is the right answer for a repository in any other
+ * language.
+ */
 export function initCli(repository, program) {
     program.command({
         command: 'info',
@@ -49,7 +57,9 @@ export function initCli(repository, program) {
             type: 'boolean',
         }),
         handler: async (args) => {
-            const systemInfo = await SystemInfo.getSystemInfo(CiService.resolvePackageManager(repository));
+            /** Only the repository - which package manager to report, if any, is a question the core
+             *  cannot ask. `rman-node`'s augmentation reads `.rmanrc "packageManager"` off this. */
+            const systemInfo = await SystemInfo.getSystemInfo({ repository });
             const repositoryInfo = SystemInfo.getRepositoryInfo(repository);
             if (args.json) {
                 console.log(JSON.stringify({ ...systemInfo, repository: repositoryInfo }, undefined, 2));

package/commands/run.command.js

@@ -1,8 +1,8 @@
 import { RunService } from '../services/run.service.js';
 import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
-import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+import { applyPackageFilterOptions, applyRootOption, readPackageFilterOptions } from '../utils/package-filter.js';
 export function applyRunOptions(cmd) {
-    return applyBranchGuardOptions(applyPackageFilterOptions(cmd))
+    return applyRootOption(applyBranchGuardOptions(applyPackageFilterOptions(cmd)), 'Run')
         .option('parallel', {
         describe: 'Max packages to build at once: omit/true for CPU count (or .rmanrc run.<script>.concurrency), ' +
             'a number for that many, false to run serially. Packages always build in dependency order.',
@@ -39,12 +39,6 @@ export function applyRunOptions(cmd) {
         .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');
 }
@@ -64,6 +58,9 @@ export function readRunOptions(args) {
 export function initCli(repository, program) {
     program.command({
         command: 'run <script>',
+        /** Which `.rmanrc` `--config` shows for this command: the script's own block, whichever
+         *  script was asked for. */
+        configKeys: (args) => ['run.' + args.script],
         describe: 'Run an npm script in each package',
         builder: cmd => applyRunOptions(cmd)
             .example('$0 run build', '')

package/commands/test.command.js

@@ -4,6 +4,7 @@ import { applyRunOptions, readRunOptions } from './run.command.js';
 export function initCli(repository, program) {
     program.command({
         command: 'test',
+        configKeys: ['run.test'],
         describe: 'Alias for "run test"',
         builder: cmd => applyRunOptions(cmd).example('$0 test', '# Tests packages'),
         handler: async (args) => {

package/commands/version.command.js

@@ -2,19 +2,32 @@ import readline from 'node:readline/promises';
 import colors from 'ansi-colors';
 import EasyTable from 'easy-table';
 import { VersionService } from '../services/version.service.js';
+import { VersionPlanService } from '../services/version-plan.service.js';
 import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
 import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
 export function initCli(repository, program) {
+    /** `rman version <bump|version>` is validated by the root's scheme (see `getPlan`), so the help
+     *  has to name that scheme's own words rather than semver's - otherwise `--help` in a repository
+     *  numbering some other way documents keywords its own planner would reject. A four-part scheme
+     *  lists four here. */
+    const { name: scheme, bumpNames } = repository.rootPackage.versionScheme;
+    const bumps = bumpNames.map(n => `"${n}"`).join('/');
+    /** For the examples. Not `smallestBump`, which throws: `--help` must still render for a scheme
+     *  that declares none, and the placeholder says what to write there. */
+    const smallest = bumpNames[0] ?? '<bump>';
     program.command({
         command: 'version [bump]',
+        /** `changelog` too: `--changelog` folds one into the bump commit, and `group` is what decides
+         *  which packages move together. */
+        configKeys: ['version', 'changelog', 'group'],
         describe: 'Bumps versions of changed packages (and their dependents), grouped via .rmanrc "group"',
         builder: cmd => applyBranchGuardOptions(applyPackageFilterOptions(cmd))
-            .example('$0 version patch', '# Bump patch severity directly, applied immediately')
-            .example('$0 version', "# Auto-detect severity from commits, show the plan, don't write anything")
+            .example(`$0 version ${smallest}`, `# Bump ${smallest} directly, applied immediately`)
+            .example('$0 version', "# Auto-detect the bump from commits, show the plan, don't write anything")
             .example('$0 version --interactive', '# Show the plan either way, then ask for confirmation')
-            .example('$0 version patch --show', '# Preview what an explicit patch bump would do, without applying it')
+            .example(`$0 version ${smallest} --show`, `# Preview what an explicit ${smallest} would do, without applying it`)
             .positional('bump', {
-            describe: 'A release-type keyword ("patch"/"minor"/"major") or an explicit semver version. ' +
+            describe: `A bump keyword (${bumps}) or an explicit ${scheme} version. ` +
                 'Omit to auto-detect from commits and only preview the plan.',
             type: 'string',
         })
@@ -25,15 +38,15 @@ export function initCli(repository, program) {
         })
             .option('show', {
             describe: 'Show the resulting plan for the given bump without applying it - unlike omitting bump ' +
-                'entirely, this still uses the given release-type keyword/version to compute the plan, ' +
+                'entirely, this still uses the given bump keyword/version to compute the plan, ' +
                 'just never writes it.',
             type: 'boolean',
         })
             .conflicts('show', 'interactive')
             .option('yes', {
             alias: 'y',
-            describe: 'Skip the confirmation prompt and apply the computed plan immediately - auto-detected ' +
-                'severity included, no explicit bump keyword required (same idea as "publish --yes").',
+            describe: 'Skip the confirmation prompt and apply the computed plan immediately - an auto-detected ' +
+                'bump included, no explicit bump keyword required (same idea as "publish --yes").',
             type: 'boolean',
         })
             .conflicts('yes', 'interactive')
@@ -61,13 +74,13 @@ export function initCli(repository, program) {
             .option('preid', {
             describe: 'Make the bump a prerelease with this identifier (e.g. "beta" -> 1.2.3-beta.0). ' +
                 'Running again with the same --preid increments it (-> 1.2.3-beta.1); a different ' +
-                'identifier starts a fresh prerelease line. Ignored when bump is an explicit semver version.',
+                `identifier starts a fresh prerelease line. Ignored when bump is an explicit ${scheme} version.`,
             type: 'string',
         }),
         handler: async (args) => {
             await assertAllowedBranch(repository, readBranchGuardOptions(args));
             const bump = args.bump;
-            const plan = await VersionService.getPlan(repository, {
+            const plan = await VersionPlanService.getPlanner().getPlan(repository, {
                 ...readPackageFilterOptions(args),
                 bump,
                 ignoreDirty: args.ignoreDirty,
@@ -107,14 +120,40 @@ export function initCli(repository, program) {
                 message: args.message,
                 changelog,
             });
-            for (const entry of applied) {
-                if (entry.status === 'bump') {
-                    console.log(colors.green('updated'), colors.cyan(entry.package.name), entry.from, '->', colors.yellow(entry.to));
-                }
-            }
+            printApplied(applied);
         },
     });
 }
+/**
+ * What the run *did* - which is deliberately not the table again.
+ *
+ * The plan is printed above, so repeating `name from -> to` per package said nothing: `applyPlan`
+ * returned the same array it was handed, so the second list could not have differed. What it never
+ * reported is everything below - the commits (one per group, plus the root's informational sync),
+ * the tags, a tag that already existed and was left alone, and whether any of it was pushed. A
+ * release that is committed but not pushed looks identical to one that is, until someone looks.
+ */
+function printApplied(result) {
+    const count = result.updated.length;
+    console.log(`\n${colors.green('updated')} ${count} package${count === 1 ? '' : 's'}`);
+    for (const commit of result.commits) {
+        console.log(`${colors.green('commit')}  ${colors.yellow(commit.sha)}  ${colors.gray(commit.message.split('\n')[0])}`);
+    }
+    if (result.tags.length) {
+        const label = (tag) => colors.cyan(tag.name) + (tag.created ? '' : colors.gray(' (existing, left alone)'));
+        const release = result.tags.filter(t => t.release);
+        const perPackage = result.tags.filter(t => !t.release);
+        if (perPackage.length)
+            console.log(`${colors.green('tags')}    ${perPackage.map(label).join(', ')}`);
+        /** Listed on its own line: it belongs to the repository rather than to any package, which is
+         *  the whole reason it exists. */
+        if (release.length)
+            console.log(`${colors.green('tags')}    ${release.map(label).join(', ')} ${colors.gray('(repository release)')}`);
+    }
+    console.log(result.pushed
+        ? `${colors.green('push')}    pushed, with tags`
+        : `${colors.gray('push')}    ${colors.gray('not pushed - run with --push, or push it yourself')}`);
+}
 function printPlan(entries) {
     const table = new EasyTable();
     for (const e of entries) {

package/constants.js

@@ -1 +1 @@
-export const version = '1.0.10';
+export const version = '1.1.1';