rman 2.11.3 → 2.13.0

package/builtins/platforms/node/services/ci.service.d.ts

@@ -33,7 +33,7 @@ export declare namespace CiService {
      * `"ci"` script, runs that instead. Once every package is clean, installs once at the root
      * with the configured package manager (`npm`/`yarn`/`pnpm`/`bun`).
      *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) while it
+     * Uses the same live progress panel as `run`/`build` (see `core/classes/progress-panel.ts`) while it
      * runs, falling back to a plain rmdir/clean/run/install log line per step when the panel is off.
      *
      * Unlike `run`/`build`, it does *not* end with a per-package success tally: `ci`'s packages don't

package/builtins/platforms/node/services/ci.service.js

@@ -2,9 +2,9 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import colors from 'ansi-colors';
 import { Logger, resolveRootLogLevel } from '../../../../core/classes/logger.js';
+import { formatDuration, ProgressPanel } from '../../../../core/classes/progress-panel.js';
 import { exec } from '../../../../utils/exec.js';
 import { filterPackages } from '../../../../utils/package-filter.js';
-import { formatDuration, ProgressPanel } from '../../../../utils/progress-panel.js';
 export var CiService;
 (function (CiService) {
     /**
@@ -53,7 +53,7 @@ export var CiService;
      * `"ci"` script, runs that instead. Once every package is clean, installs once at the root
      * with the configured package manager (`npm`/`yarn`/`pnpm`/`bun`).
      *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) while it
+     * Uses the same live progress panel as `run`/`build` (see `core/classes/progress-panel.ts`) while it
      * runs, falling back to a plain rmdir/clean/run/install log line per step when the panel is off.
      *
      * Unlike `run`/`build`, it does *not* end with a per-package success tally: `ci`'s packages don't

package/builtins/platforms/node/services/clean.service.d.ts

@@ -46,7 +46,7 @@ export declare namespace CleanService {
      * Run from inside a single package's own directory, it only cleans that package unless
      * `options.fromRoot` says otherwise (see `Repository.currentPackage`).
      *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) - unlike
+     * Uses the same live progress panel as `run`/`build` (see `core/classes/progress-panel.ts`) - unlike
      * `ci`, cleaning genuinely is independent per-package work, so the final per-package tally stays.
      */
     function clean(repository: Repository, options?: Options): Promise<void>;

package/builtins/platforms/node/services/clean.service.js

@@ -3,8 +3,8 @@ import path from 'node:path';
 import colors from 'ansi-colors';
 import fg from 'fast-glob';
 import { Logger, resolveRootLogLevel } from '../../../../core/classes/logger.js';
+import { ProgressPanel } from '../../../../core/classes/progress-panel.js';
 import { filterPackages } from '../../../../utils/package-filter.js';
-import { ProgressPanel } from '../../../../utils/progress-panel.js';
 export var CleanService;
 (function (CleanService) {
     /**
@@ -38,7 +38,7 @@ export var CleanService;
      * Run from inside a single package's own directory, it only cleans that package unless
      * `options.fromRoot` says otherwise (see `Repository.currentPackage`).
      *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) - unlike
+     * Uses the same live progress panel as `run`/`build` (see `core/classes/progress-panel.ts`) - unlike
      * `ci`, cleaning genuinely is independent per-package work, so the final per-package tally stays.
      */
     async function clean(repository, options = {}) {

package/builtins/platforms/node/services/publish.service.d.ts

@@ -128,6 +128,15 @@ export declare namespace PublishService {
      * excludes it for a real monorepo (it only doubles as "the" package in a single-package repo,
      * where it's a normal candidate like any other).
      */
+    /**
+     * Why the npm target leaves `pkg` alone, from its manifest alone - `'private package'`, or
+     * `undefined` when it would be published. `rman list` asks this to grey a package out.
+     */
+    function skipReason(pkg: Package, contentsOverride?: string): string | undefined;
+    /** The host of a package's `publishConfig.registry` - `npm.pkg.github.com` for GitHub Packages -
+     *  or `undefined` where it names none, or names npm's own registry. What `rman list` shows in
+     *  place of `npm`. */
+    function registryLabel(pkg: Package): string | undefined;
     function getPlan(repository: Repository, options?: Options, deps?: Deps): Promise<Entry[]>;
     /**
      * Publishes every `'publish'` entry in `plan`, topological order (already `plan`'s own order -

package/builtins/platforms/node/services/publish.service.js

@@ -153,6 +153,46 @@ export var PublishService;
      * excludes it for a real monorepo (it only doubles as "the" package in a single-package repo,
      * where it's a normal candidate like any other).
      */
+    /**
+     * Why the npm target leaves `pkg` alone, from its manifest alone - `'private package'`, or
+     * `undefined` when it would be published. `rman list` asks this to grey a package out.
+     */
+    /* **The one statement of npm's `private` rule**, called by `getPlan` and by `NpmPublishTarget.
+     * skipReason` both, so the plan and the list cannot disagree. Two cases, both private:
+     * - **no `publishConfig`** (`privateBySource`) - private in the published manifest too, wherever it
+     *   is published from;
+     * - **published in place** - the source manifest *is* the published one, so its `private` stands
+     *   whatever else it declares.
+     * The second sat after the build-output check in `getPlan` and moved ahead of it unchanged:
+     * `hasBuildOutput` is always true in place, so nothing reached it any differently. */
+    function skipReason(pkg, contentsOverride) {
+        if (!pkg.manifest.raw.private)
+            return undefined;
+        if (privateBySource(pkg) || publishesInPlace(pkg, contentsOverride))
+            return 'private package';
+        return undefined;
+    }
+    PublishService.skipReason = skipReason;
+    /** The host of a package's `publishConfig.registry` - `npm.pkg.github.com` for GitHub Packages -
+     *  or `undefined` where it names none, or names npm's own registry. What `rman list` shows in
+     *  place of `npm`. */
+    /* **`publishConfig.registry` only**, which is one package's own statement. A scoped
+     * `@owner:registry=` in `.npmrc` also sends a package elsewhere, and is not read: npm resolves it
+     * itself (see `resolveRegistry`), so such a package still shows `npm`. A value that is not a URL
+     * shows `npm` too - `npm publish` is what will say it is wrong. */
+    function registryLabel(pkg) {
+        const registry = resolveRegistry(pkg, undefined);
+        if (!registry)
+            return undefined;
+        try {
+            const host = new URL(registry).hostname;
+            return host && host !== NPMJS_HOST ? host : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    PublishService.registryLabel = registryLabel;
     async function getPlan(repository, options = {}, deps = {}) {
         const git = new GitHelper({ cwd: repository.dirname });
         const packages = filterPackages(repository.getPackages({ toposort: true }), options);
@@ -173,6 +213,7 @@ export var PublishService;
              *  finding that out after a round trip per package would be a slower way to the same
              *  refusal. */
             const distTag = distTagFor(pkg, options.tag);
+            const privateReason = skipReason(pkg, options.contents);
             if (retiredDirectoryKey(pkg)) {
                 entries.set(pkg.name, {
                     package: pkg,
@@ -189,8 +230,8 @@ export var PublishService;
                     reason: 'excluded via .rmanrc "publish.skip"',
                 });
             }
-            else if (privateBySource(pkg)) {
-                entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: 'private package' });
+            else if (privateReason) {
+                entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: privateReason });
             }
             else if (!hasBuildOutput(pkg, options.contents)) {
                 const dir = path.relative(pkg.dirname, resolvePublishDir(pkg, options.contents)) || '.';
@@ -201,9 +242,6 @@ export var PublishService;
                     reason: `nothing to publish in "${dir}" - it is missing or empty; build the package first`,
                 });
             }
-            else if (publishesInPlace(pkg, options.contents) && pkg.manifest.raw.private) {
-                entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: 'private package' });
-            }
             else if (distTag.error) {
                 entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'error', reason: distTag.error });
             }
@@ -413,6 +451,8 @@ function resolveRegistry(pkg, override) {
     const native = pkg.manifest.raw.publishConfig?.registry;
     return override || (typeof native === 'string' && native ? native : undefined);
 }
+/** npm's own registry, which `PublishService.registryLabel` leaves shown as `npm`. */
+const NPMJS_HOST = 'registry.npmjs.org';
 /**
  * The retired `publish.directory` spelling, if a config still carries it.
  *

package/builtins/publish-targets/npm/npm-publish-target.d.ts

@@ -1,3 +1,4 @@
+import type { Package } from '../../../core/classes/package.js';
 import type { PublishTarget } from '../../../core/interfaces/publish-target.js';
 import { PublishService } from '../../platforms/node/services/publish.service.js';
 /** The name this target answers to in `publish.target` and `--target`. */
@@ -70,6 +71,10 @@ export declare class NpmPublishTarget implements PublishTarget {
             type: "string";
         };
     };
+    /** npm's `private` rule, the same function `getPlan` asks. */
+    skipReason(pkg: Package): string | undefined;
+    /** The registry's host where `publishConfig.registry` names one other than npm's own. */
+    labelFor(pkg: Package): string | undefined;
     getPlan(ctx: PublishTarget.Context): Promise<PublishService.Entry[]>;
     applyPlan(ctx: PublishTarget.Context, plan: PublishTarget.Entry[]): Promise<PublishService.Entry[]>;
     /** The shared filters plus the two flags both halves need - read here rather than in the

package/builtins/publish-targets/npm/npm-publish-target.js

@@ -75,6 +75,14 @@ export class NpmPublishTarget {
             type: 'string',
         },
     };
+    /** npm's `private` rule, the same function `getPlan` asks. */
+    skipReason(pkg) {
+        return PublishService.skipReason(pkg);
+    }
+    /** The registry's host where `publishConfig.registry` names one other than npm's own. */
+    labelFor(pkg) {
+        return PublishService.registryLabel(pkg);
+    }
     getPlan(ctx) {
         return PublishService.getPlan(ctx.repository, this.planOptions(ctx));
     }

package/commands/changelog.command.js

@@ -1,10 +1,10 @@
 import path from 'node:path';
 import colors from 'ansi-colors';
 import { Logger, resolveRootLogLevel } from '../core/classes/logger.js';
+import { ProgressPanel } from '../core/classes/progress-panel.js';
 import { registerCommand } from '../interfaces/rman-config.interface.js';
 import { ChangeHashService } from '../services/change-hash.service.js';
 import { fromRootOption, packageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
-import { ProgressPanel } from '../utils/progress-panel.js';
 const COMMAND = 'changelog';
 const config = {
     ...packageFilterOptions,

package/commands/list.command.js

@@ -2,6 +2,7 @@ import colors from 'ansi-colors';
 import EasyTable from 'easy-table';
 import { registerCommand } from '../interfaces/rman-config.interface.js';
 import { packageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+import { isNamedGroupKey, isSoloGroupKey, ROOT_GROUP_KEY } from '../utils/version-group.js';
 /** `[options...]` is yargs-meaningless - its variadic marker is two dots, and this command declares
  *  no positional for it. Left as it is rather than fixed in passing: dropping it makes
  *  `rman list foo` start failing, which is a behaviour change and belongs in its own commit. */
@@ -82,8 +83,9 @@ const listCommand = registerCommand(app => {
              * so counting rows that are not the root reported `0 Package(s) found` there (measured). The
              * condition is the same one the service applies, and it is one line.
              */
+            /** Grouped, except where the order *is* the answer: `--toposort` is dependency order. */
             else
-                printTable(items, table && app.repository.monorepo);
+                printTable(args.toposort ? items : byGroup(items), table && app.repository.monorepo);
         },
     };
 });
@@ -100,6 +102,55 @@ function statusLabel(status) {
             return '';
     }
 }
+/** Where a package ships, one target each - its label where it has one (`Item.targetLabels`, npm's
+ *  registry host). A target `publish` would skip it for (`Item.skippedTargets`) is left out, and a
+ *  package left with none reads `-`, so the column never reads as a promise the release will not
+ *  keep. Blank where no target claims the package at all - a monorepo's root, for one. */
+function publishLabel(it) {
+    if (!it.publishTargets.length)
+        return '';
+    const shipping = it.publishTargets.filter(name => !it.skippedTargets[name]);
+    if (!shipping.length)
+        return colors.gray('-');
+    return shipping.map(name => colors.green(it.targetLabels[name] ?? name)).join(', ');
+}
+/**
+ * The rows with each release group's members together - the root first, then the groups in the
+ * order their first member appears, then the packages in no group (`group: false`) - the order
+ * `version`'s plan prints them in. Stable within a group, so the lexical order holds there.
+ */
+/* The cost, stated: a package nested inside another can land away from it, when the two are in
+ * different groups - its indentation still says how deep it sits, not under which row. */
+function byGroup(items) {
+    const root = items.filter(it => it.groupKey === ROOT_GROUP_KEY);
+    const groups = new Map();
+    const solo = [];
+    for (const it of items) {
+        if (it.groupKey === ROOT_GROUP_KEY)
+            continue;
+        if (isSoloGroupKey(it.groupKey))
+            solo.push(it);
+        else
+            groups.set(it.groupKey, [...(groups.get(it.groupKey) ?? []), it]);
+    }
+    return [...root, ...[...groups.values()].flat(), ...solo];
+}
+/** Whether the Group column says anything: a group the repository named, or the default group
+ *  beside packages in none. One line for everything, or no grouping at all, would put the same
+ *  answer - or nothing - on every row. */
+function showsGroups(items) {
+    const keys = items.map(it => it.groupKey).filter(key => key !== ROOT_GROUP_KEY);
+    return keys.some(isNamedGroupKey) || (keys.includes('default') && keys.some(isSoloGroupKey));
+}
+/** A named group by its name, the default one as a grey `(default)` - `version`'s plan table reads
+ *  the same way. Blank for the root and for a package in no group. */
+function groupCell(it) {
+    if (isNamedGroupKey(it.groupKey))
+        return colors.cyan(it.group);
+    if (it.groupKey === 'default')
+        return colors.gray('(default)');
+    return '';
+}
 /**
  * **The tree, as a table**: the root first, then each package indented by how far below it sits.
  *
@@ -120,12 +171,16 @@ function statusLabel(status) {
  */
 function printTable(items, withRoot) {
     const table = new EasyTable();
+    const withGroup = showsGroups(items);
     for (const it of items) {
         const indent = '  '.repeat(it.depth);
         table.cell('Package', indent + (it.isRoot ? colors.whiteBright(it.selector) : colors.yellowBright(it.selector)));
         table.cell('Version', colors.yellow(it.version));
+        if (withGroup)
+            table.cell('Group', groupCell(it));
         table.cell('Platform', it.platform ? colors.cyan(it.platform) : '');
         table.cell('Private', it.private ? colors.magentaBright('yes') : '');
+        table.cell('Publish', publishLabel(it));
         table.cell('Changed', statusLabel(it.status));
         table.cell('Path', it.location);
         table.newRow();

package/constants.js

@@ -1 +1 @@
-export const version = '2.11.3';
+export const version = '2.13.0';

package/core/classes/log-sink.d.ts

@@ -1,5 +1,5 @@
-import type { ProgressItem } from '../../utils/progress-panel.js';
 import type { LogLevel } from './logger.js';
+import type { ProgressItem } from './progress-panel.js';
 /**
  * One thing that happened during a run, in the order it happened. The JSON form is exactly this
  * object with a `time` added; the text form is one line per event.

package/{utils → core/classes}/progress-panel.d.ts

@@ -1,5 +1,5 @@
+import type { StatusRegion, TerminalRegion } from '../../utils/status-region.js';
 import { LiveRegion } from './live-region.js';
-import type { StatusRegion, TerminalRegion } from './status-region.js';
 export type ProgressStatus = 'pending' | 'running' | 'success' | 'failed' | 'skipped';
 export interface ProgressItem {
     readonly name: string;

package/core/classes/run-reporters.d.ts

@@ -1,6 +1,6 @@
-import type { ProgressPanel } from '../../utils/progress-panel.js';
 import type { LogEvent, Reporter, ReportOrigin } from './log-sink.js';
 import { type LogLevel } from './logger.js';
+import type { ProgressPanel } from './progress-panel.js';
 /**
  * The screen with no live panel: each line a step prints, led by its package, and one line per step
  * when it ends - the output `--no-progress`, a pipe or CI gets.

package/core/interfaces/publish-target.d.ts

@@ -61,6 +61,19 @@ export interface PublishTarget {
      * let through.
      */
     claims?(pkg: Package): boolean;
+    /**
+     * Why this target would leave a package it ships to alone, or `undefined` when it would not -
+     * answered from the config and the manifest alone, with no registry and no build.
+     *
+     * `publish.skip` is the core's and is asked before this (see `skipReasonFor`); a target answers
+     * only what is its own, such as npm's `private`.
+     */
+    skipReason?(pkg: Package): string | undefined;
+    /**
+     * The name `rman list` shows for this package when it says more than `name` does - npm's is the
+     * registry's host, `npm.pkg.github.com` for GitHub Packages. `undefined` shows `name`.
+     */
+    labelFor?(pkg: Package): string | undefined;
     /** What this target *would* do - never publishes. Called even under `--dry-run`, which is the
      *  whole point of the split. */
     getPlan(ctx: PublishTarget.Context): Promise<PublishTarget.Entry[]>;
@@ -131,6 +144,10 @@ export declare function shipsTo(pkg: Package, target: PublishTarget): boolean;
 /** Every registered target `pkg` ships to, in registration order. The single answer to "where does
  *  this package go", so `publish` and `list --json` cannot disagree about it. */
 export declare function targetsOf(app: RmanApplication, pkg: Package): PublishTarget[];
+/** Why `target` would leave `pkg` alone, or `undefined` when it would publish it: `.rmanrc
+ *  "publish.skip"`, which excludes a package from every target, and then the target's own
+ *  `skipReason`. */
+export declare function skipReasonFor(pkg: Package, target: PublishTarget): string | undefined;
 /** Names in a package's `publish.target` that no registered target answers to - a misconfiguration
  *  that used to be caught by a `choices: ['npm', 'docker']` the core can no longer write down. */
 export declare function unknownTargets(app: RmanApplication, pkg: Package): string[];

package/core/interfaces/publish-target.js

@@ -32,6 +32,14 @@ export function shipsTo(pkg, target) {
 export function targetsOf(app, pkg) {
     return app.publishTargets.all.filter(target => shipsTo(pkg, target));
 }
+/** Why `target` would leave `pkg` alone, or `undefined` when it would publish it: `.rmanrc
+ *  "publish.skip"`, which excludes a package from every target, and then the target's own
+ *  `skipReason`. */
+export function skipReasonFor(pkg, target) {
+    if (pkg.config.publish?.skip)
+        return 'excluded via .rmanrc "publish.skip"';
+    return target.skipReason?.(pkg);
+}
 /** Names in a package's `publish.target` that no registered target answers to - a misconfiguration
  *  that used to be caught by a `choices: ['npm', 'docker']` the core can no longer write down. */
 export function unknownTargets(app, pkg) {

package/index.d.ts

@@ -65,7 +65,7 @@ export { Manifest } from './core/interfaces/manifest.js';
 export { Registry } from './core/classes/registry.js';
 export { Repository } from './core/classes/repository.js';
 export { Service, type ServiceFactory, type ServiceMap } from './core/classes/service.js';
-export { declaredTargets, type PublishTarget, shipsTo, targetsOf, unknownTargets, } from './core/interfaces/publish-target.js';
+export { declaredTargets, type PublishTarget, shipsTo, skipReasonFor, targetsOf, unknownTargets, } from './core/interfaces/publish-target.js';
 export type { RunConditionFn, RunStepContext, RunStepFn, RunStepObject, RunStepValue, } from './core/interfaces/run-step.js';
 /**
  * **`Platform` is one technology, whole**; **`Plugin` is whatever a package contributes**, platforms
@@ -145,7 +145,7 @@ export { GitHelper } from './utils/git.js';
 export { applyFromRootOption, applyPackageFilterOptions, filterPackages, fromRootOption, type PackageFilterOptions, packageFilterOptions, readFromRootOption, readPackageFilterOptions, ROOT_SELECTOR, } from './utils/package-filter.js';
 /** The live panel `run`/`build`/`clean` print - a plugin's per-package command looks like the rest
  *  of rman instead of like a script someone bolted on. */
-export { formatDuration, type ProgressItem, ProgressPanel, type ProgressStatus, type ProgressSummary, } from './utils/progress-panel.js';
+export { formatDuration, type ProgressItem, ProgressPanel, type ProgressStatus, type ProgressSummary, } from './core/classes/progress-panel.js';
 /** Version stamping helpers a `Plugin.stampVersion` can delegate to - the quoted-constant
  *  pattern most languages share, and the OCI Dockerfile label (which `version` stamps itself, since
  *  the label's value is by specification the package's version). */

package/index.js

@@ -71,7 +71,7 @@ export { Manifest } from './core/interfaces/manifest.js';
 export { Registry } from './core/classes/registry.js';
 export { Repository } from './core/classes/repository.js';
 export { Service } from './core/classes/service.js';
-export { declaredTargets, shipsTo, targetsOf, unknownTargets, } from './core/interfaces/publish-target.js';
+export { declaredTargets, shipsTo, skipReasonFor, targetsOf, unknownTargets, } from './core/interfaces/publish-target.js';
 export { basePlatform, definePlatform, definePlugin, isPlatform, } from './core/interfaces/plugin.js';
 /** The numbering seam. `VersionScheme` is abstract - `highestVersion`/`highestBump`/`smallestBump`
  *  are implemented from the members around them, so a scheme states only what it must and still
@@ -128,7 +128,7 @@ export { GitHelper } from './utils/git.js';
 export { applyFromRootOption, applyPackageFilterOptions, filterPackages, fromRootOption, packageFilterOptions, readFromRootOption, readPackageFilterOptions, ROOT_SELECTOR, } from './utils/package-filter.js';
 /** The live panel `run`/`build`/`clean` print - a plugin's per-package command looks like the rest
  *  of rman instead of like a script someone bolted on. */
-export { formatDuration, ProgressPanel, } from './utils/progress-panel.js';
+export { formatDuration, ProgressPanel, } from './core/classes/progress-panel.js';
 export { CiService } from './builtins/platforms/node/services/ci.service.js';
 export { CleanService } from './builtins/platforms/node/services/clean.service.js';
 export { PublishService } from './builtins/platforms/node/services/publish.service.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.11.3",
+  "version": "2.13.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

package/services/changelog.service.d.ts

@@ -1,6 +1,7 @@
 import type { Package } from '../core/classes/package.js';
 import type { Repository } from '../core/classes/repository.js';
 import { Service } from '../core/classes/service.js';
+import { GitHelper } from '../utils/git.js';
 import { type PackageFilterOptions } from '../utils/package-filter.js';
 /**
  * A service class - see `ListService` for the shape and `Service` for the three measured
@@ -55,6 +56,12 @@ export declare class ChangelogService extends Service {
      * `options.fromRoot` says otherwise (see `Repository.currentPackage`).
      */
     getEntries(options?: ChangelogService.Options): Promise<ChangelogService.Entry[]>;
+    /**
+     * Where each member package's directory was over time, newest first - `since` is the commit that
+     * moved it there, absent for the oldest. A package that never moved has one entry, its own
+     * directory. Read from the moves of the package's manifest (`GitHelper.moveHistory`).
+     */
+    protected packageHomes(git: GitHelper): Promise<PackageHomes>;
 }
 /**
  * What one changelog file is about - `.rmanrc changelog.groupBy`, `'package'` when nothing says.
@@ -68,6 +75,13 @@ export declare class ChangelogService extends Service {
  * per package - the same entry prepended once per member otherwise.
  */
 export declare function changelogGroupBy(repository: Repository, options?: ChangelogService.Options): 'package' | 'group';
+/** Where a package's directory was over time, newest first - see `ChangelogService.packageHomes`. */
+type PackageHomes = Map<Package, Home[]>;
+interface Home {
+    dir: string;
+    /** The commit that moved the package here; absent for its first directory. */
+    since?: string;
+}
 export declare namespace ChangelogService {
     interface Options extends PackageFilterOptions {
         /** Generate the changelog since this commit/hash - applied the same way to every package.
@@ -212,3 +226,4 @@ declare module '../core/classes/service.js' {
         changelog: ChangelogService;
     }
 }
+export {};

package/services/changelog.service.js

@@ -154,6 +154,9 @@ export class ChangelogService extends Service {
             progress?.step(group.label, 'commits');
             return listCommitsCached(from, group.label);
         }));
+        /** Where each package's directory was over time - so a commit made before a package moved is
+         *  still its own. See `packageHomes`. */
+        const homes = await this.packageHomes(git);
         const entries = [];
         for (let i = 0; i < groups.length; i++) {
             const group = groups[i];
@@ -177,6 +180,7 @@ export class ChangelogService extends Service {
              * falls inside the range and there is exactly one segment - which is what `version
              * --changelog` and `github-release` see too, since both pass an explicit boundary.
              */
+            const dirsAt = homesAt(homes, commitsByTarget[i]);
             const floor = await resolveStartingPoint(git, pkg, options);
             const floorIndex = floor?.sha ? commitsByTarget[i].findIndex(c => c.sha === floor.sha) : -1;
             const withUnreleased = resolveUnreleased(pkg, options);
@@ -189,7 +193,7 @@ export class ChangelogService extends Service {
                     continue;
                 /** A commit belongs to a group when it belongs to **any** of its members - one line for a
                  *  commit touching two of them, which is the whole reason a group shares a file. */
-                const ownCommits = dropVersionBumps(segment.commits).filter(c => [...ownersOf(repository, c)].some(owner => group.members.has(owner)));
+                const ownCommits = dropVersionBumps(segment.commits).filter(c => [...ownersOf(repository, c, dirsAt(c))].some(owner => group.members.has(owner)));
                 if (!ownCommits.length)
                     continue;
                 const sections = groupCommits(ownCommits, ignoreTypesConfig(pkg), titles, order, withCommitHash(pkg, options));
@@ -219,6 +223,33 @@ export class ChangelogService extends Service {
         }
         return entries;
     }
+    /**
+     * Where each member package's directory was over time, newest first - `since` is the commit that
+     * moved it there, absent for the oldest. A package that never moved has one entry, its own
+     * directory. Read from the moves of the package's manifest (`GitHelper.moveHistory`).
+     */
+    /* **Why a commit cannot simply be matched against today's directories**: measured on
+     * `panates/syncbridge`, whose last commit moved every package under `packages/<scope>/`. Every
+     * earlier commit touched the old paths, which no package sits at any more, so all of them were
+     * attributed to the root - `changelog --write` under `groupBy: package` wrote one root file and
+     * nothing for any package, while git still held 259 commits of hl7's and 283 of iomt's.
+     *
+     * **The manifest, not the files**: one file per package says where its directory was, so this is
+     * one `git log --follow` per package, run at once - 40ms each there, 120ms on `panates/sqb`. A
+     * single-package repository has nothing to follow: its package is the root, which does not move. */
+    async packageHomes(git) {
+        const homes = new Map();
+        const packages = this.repository.monorepo ? this.repository.packages : [];
+        await Promise.all(packages.map(async (pkg) => {
+            if (!pkg.manifestFileName)
+                return;
+            const moves = await git.moveHistory(pkg.manifestFileName);
+            const periods = [{ dir: pkg.dirname, since: moves[0]?.sha }];
+            moves.forEach((move, k) => periods.push({ dir: path.dirname(move.from), since: moves[k + 1]?.sha }));
+            homes.set(pkg, periods);
+        }));
+        return homes;
+    }
 }
 /**
  * What one changelog file is about - `.rmanrc changelog.groupBy`, `'package'` when nothing says.
@@ -856,16 +887,45 @@ async function splitByRelease(git, pkg, commits) {
  *  fallback for anything outside every package (e.g. root-level config files). Mirrors
  *  `Repository.currentPackage`'s longest-prefix logic, but always resolves to *something*
  *  (root), rather than `undefined`, since every file belongs to some changelog. */
-function owningPackage(repository, file) {
+function owningPackage(repository, file, dirOf) {
     let best = repository.rootPackage;
+    let bestDir = repository.rootPackage.dirname;
     for (const pkg of repository.packages) {
-        const rel = path.relative(pkg.dirname, file);
+        const dir = dirOf(pkg);
+        const rel = path.relative(dir, file);
         const isSelfOrDescendant = rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
-        if (isSelfOrDescendant && pkg.dirname.length > best.dirname.length)
+        if (isSelfOrDescendant && dir.length > bestDir.length) {
             best = pkg;
+            bestDir = dir;
+        }
     }
     return best;
 }
+/**
+ * For one fetched commit list, the function that answers where each package's directory was when a
+ * given commit was made.
+ */
+/* **Ordered by position in the list, not by asking git**: the list is oldest first and runs to HEAD,
+ * so a move inside it is compared by index, and a move *not* in it happened at or before the range's
+ * boundary - every commit in the range is after it. One `merge-base --is-ancestor` per commit and
+ * package would be the exact answer and costs a process each; this costs a Map. */
+function homesAt(homes, commits) {
+    const index = new Map(commits.map((c, i) => [c.sha, i]));
+    return commit => pkg => {
+        const periods = homes.get(pkg);
+        if (!periods)
+            return pkg.dirname;
+        const at = index.get(commit.sha) ?? commits.length;
+        for (const period of periods) {
+            if (!period.since)
+                return period.dir;
+            const movedAt = index.get(period.since);
+            if (movedAt === undefined || movedAt <= at)
+                return period.dir;
+        }
+        return periods[periods.length - 1].dir;
+    };
+}
 /** A commit touching more than this fraction of all packages (a repo-wide relicense, a doc
  *  update stamped into every package's README, ...) is treated as a repo-wide change rather than
  *  attributed to each of them - see `ownersOf`. Without this, one such commit would show up
@@ -883,10 +943,10 @@ const BROAD_COMMIT_MIN_PACKAGES = 3;
  * doc pass across every package, ...), not something that belongs in each package's own release
  * notes individually - it's attributed to the root alone.
  */
-function ownersOf(repository, commit) {
+function ownersOf(repository, commit, dirOf) {
     const owners = new Set();
     for (const f of commit.files)
-        owners.add(owningPackage(repository, f));
+        owners.add(owningPackage(repository, f, dirOf));
     const totalPackages = repository.packages.length;
     const nonRootOwners = [...owners].filter(p => p !== repository.rootPackage).length;
     if (totalPackages > 0 &&

package/services/exec.service.js

@@ -2,10 +2,10 @@ import os from 'node:os';
 import colors from 'ansi-colors';
 import { Task } from 'power-tasks';
 import { Logger, resolveRootLogLevel } from '../core/classes/logger.js';
+import { ProgressPanel } from '../core/classes/progress-panel.js';
 import { Service } from '../core/classes/service.js';
 import { exec as execCommand } from '../utils/exec.js';
 import { filterPackages } from '../utils/package-filter.js';
-import { ProgressPanel } from '../utils/progress-panel.js';
 /**
  * A service class - see `ListService` for the shape and `Service` for the three measured
  * consequences a namespace had. `repository` left the signature because the application carries it.

package/services/list.service.d.ts

@@ -63,6 +63,15 @@ export declare namespace ListService {
          * `--toposort` - which reorders the rows and leaves the nesting where it is.
          */
         depth: number;
+        /**
+         * Which release group the package versions with - `.rmanrc group`, the key `version` batches its
+         * plan by: `default` for the implicit repo-wide group, `named:<name>` for a named one,
+         * `solo:<package>` for `group: false`, and `__root__` for a monorepo's root, which belongs to
+         * none. The same spelling `version --json` reports.
+         */
+        groupKey: string;
+        /** `groupKey`'s name - the group's own name, `default`, the package's for a solo one, `root`. */
+        group: string;
         /** Whether this row *is* the root package - present only when `includeRoot` asked for it, or in
          *  a single-package repository where the root is the one member. */
         isRoot: boolean;
@@ -76,6 +85,15 @@ export declare namespace ListService {
          *  declares one, otherwise every registered target that claims it, which is the same question
          *  `publish` asks. Empty in a repository whose plugins contribute no target the package fits. */
         publishTargets: PublishTargetName[];
+        /** The entries of `publishTargets` that `publish` would leave this package alone for, each with
+         *  why - `.rmanrc "publish.skip"`, or the target's own rule (npm's `private`). Decided without the
+         *  registry, so `{}` means "a candidate", not "will publish": whether the version is already out
+         *  there is `publish --dry-run`'s answer. */
+        skippedTargets: Record<PublishTargetName, string>;
+        /** What the table shows in place of a target's name, where the target says more for this
+         *  package - npm's registry host when `publishConfig.registry` names one other than npm's own
+         *  (`{ npm: 'npm.pkg.github.com' }`). A label only: `publishTargets` and `--target` keep the name. */
+        targetLabels: Record<PublishTargetName, string>;
         /** Present only when `"docker"` is one of `publishTargets` and `publish.docker` is configured -
          *  the raw `.rmanrc` config, unresolved (no namespace prefixing - see `DockerPublishService`). */
         docker?: DockerPublishOptions;

package/services/list.service.js

@@ -1,7 +1,8 @@
 import path from 'path';
 import { Service } from '../core/classes/service.js';
-import { targetsOf } from '../core/interfaces/publish-target.js';
+import { skipReasonFor, targetsOf } from '../core/interfaces/publish-target.js';
 import { filterPackages } from '../utils/package-filter.js';
+import { groupKeyOf, isNamedGroupKey, isSoloGroupKey, ROOT_GROUP_KEY } from '../utils/version-group.js';
 /**
  * **A class, and the shape every service follows now.**
  *
@@ -33,19 +34,41 @@ export class ListService extends Service {
             /** **Asked, not assumed.** This read the config key directly and defaulted to `['npm']`, so a
              *  Cargo package in a polyglot repository was reported as shipping to npm - which is what
              *  `PublishTarget.claims` exists to answer, per target, from the ecosystem that knows. */
-            const publishTargets = targetsOf(this.app, p).map(t => t.name);
+            /** **A monorepo's root ships nowhere**: `publish` never makes it a candidate
+             *  (`repository.getPackages()` leaves it out), so listing the target a root *would* claim
+             *  says something no command does. */
+            const monorepoRoot = p === repository.rootPackage && repository.monorepo;
+            const targets = monorepoRoot ? [] : targetsOf(this.app, p);
+            /** The root's own key, as in `version`'s plan: a monorepo's root is never a group member - its
+             *  number is the repository's identity. */
+            const groupKey = monorepoRoot ? ROOT_GROUP_KEY : groupKeyOf(p);
+            const publishTargets = targets.map(t => t.name);
+            const skippedTargets = {};
+            const targetLabels = {};
+            for (const target of targets) {
+                const reason = skipReasonFor(p, target);
+                if (reason)
+                    skippedTargets[target.name] = reason;
+                const label = target.labelFor?.(p);
+                if (label && label !== target.name)
+                    targetLabels[target.name] = label;
+            }
             return {
                 name: p.name,
                 selector: p.selector,
                 version: p.version,
                 platform: p.provider,
                 depth: depthOf(p),
+                groupKey,
+                group: groupNameOf(groupKey),
                 isRoot: p === repository.rootPackage,
                 location: path.relative(repository.dirname, p.dirname) || '.',
                 private: p.isPrivate,
                 status: status[p.selector],
                 dependencies: p.dependencies.map(d => d.name),
                 publishTargets: [...publishTargets],
+                skippedTargets,
+                targetLabels,
                 docker: publishTargets.includes('docker') ? p.config.publish?.docker : undefined,
             };
         };
@@ -79,3 +102,13 @@ function depthOf(pkg) {
         depth++;
     return depth;
 }
+/** The name behind a group key - the same reading `VersionPlanService.groupLabel` makes. */
+function groupNameOf(key) {
+    if (key === ROOT_GROUP_KEY)
+        return 'root';
+    if (isNamedGroupKey(key))
+        return key.slice('named:'.length);
+    if (isSoloGroupKey(key))
+        return key.slice('solo:'.length);
+    return key;
+}

package/services/run.service.d.ts

@@ -1,11 +1,11 @@
 import type { Reporter } from '../core/classes/log-sink.js';
 import { type LogLevel } from '../core/classes/logger.js';
 import type { Package } from '../core/classes/package.js';
+import { ProgressPanel } from '../core/classes/progress-panel.js';
 import type { Repository } from '../core/classes/repository.js';
 import { Service } from '../core/classes/service.js';
 import type { RunStepContext, RunStepFn, RunStepValue } from '../core/interfaces/run-step.js';
 import { type PackageFilterOptions } from '../utils/package-filter.js';
-import { ProgressPanel } from '../utils/progress-panel.js';
 /**
  * A service class - see `ListService` for the shape and `Service` for the three measured
  * consequences a namespace had.

package/services/run.service.js

@@ -5,11 +5,11 @@ import colors from 'ansi-colors';
 import { tokenize } from 'fast-tokenizer';
 import { Task } from 'power-tasks';
 import { LOG_LEVELS, Logger, resolveRootLogLevel } from '../core/classes/logger.js';
+import { ProgressPanel } from '../core/classes/progress-panel.js';
 import { PanelReporter, PlainReporter } from '../core/classes/run-reporters.js';
 import { Service } from '../core/classes/service.js';
 import { exec } from '../utils/exec.js';
 import { filterPackages } from '../utils/package-filter.js';
-import { ProgressPanel } from '../utils/progress-panel.js';
 import { runBin } from '../utils/run-bin.js';
 /**
  * A service class - see `ListService` for the shape and `Service` for the three measured

package/utils/git.d.ts

@@ -12,6 +12,8 @@ export interface CommitInfo {
 }
 export declare class GitHelper {
     cwd: string;
+    /** `movedShare`'s per-commit rename lists. */
+    private _renames;
     constructor(options?: GitOptions);
     /** The current branch name, or `undefined` in detached HEAD state (or outside a git repository) -
      *  what `branch-guard.ts` checks `allowBranch`/`ignoreBranch` against. */
@@ -67,6 +69,21 @@ export declare class GitHelper {
      *  never been committed. Answers "since when has this file last been updated", independent of
      *  any tag/version scheme - e.g. to check whether a changelog file has fallen behind. */
     lastCommitTouching(file: string): Promise<string | undefined>;
+    /**
+     * Every time `file` was **moved together with its directory**, newest first - `{ sha, from, to }`,
+     * absolute paths of the file, and the commit that moved it. Empty for a file that never moved, or
+     * one git has no history of. Meant for a package manifest: where it went, its package went.
+     */
+    moveHistory(file: string): Promise<{
+        sha: string;
+        from: string;
+        to: string;
+    }[]>;
+    /**
+     * Of the files `fromDir` held just before `sha`, the share `sha` renamed into `toDir` - `0` to `1`.
+     * Both directories relative to `cwd`, in git's `/` form.
+     */
+    movedShare(sha: string, fromDir: string, toDir: string): Promise<number>;
     /** The best common ancestor of `a` and `b` - `undefined` if none exists (unrelated histories,
      *  an invalid ref, ...). */
     mergeBase(a: string, b: string): Promise<string | undefined>;

package/utils/git.js

@@ -3,6 +3,8 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 export class GitHelper {
     cwd;
+    /** `movedShare`'s per-commit rename lists. */
+    _renames = new Map();
     constructor(options) {
         this.cwd = options?.cwd || process.cwd();
     }
@@ -203,6 +205,88 @@ export class GitHelper {
             return undefined;
         }
     }
+    /**
+     * Every time `file` was **moved together with its directory**, newest first - `{ sha, from, to }`,
+     * absolute paths of the file, and the commit that moved it. Empty for a file that never moved, or
+     * one git has no history of. Meant for a package manifest: where it went, its package went.
+     */
+    /* **Renames only, and the walk stops at the first copy.** `git log --follow` also crosses a *copy*
+     * (`C`), and for a manifest that is the dangerous case: package manifests resemble one another, so a
+     * new package created from an old one's `package.json` is followed into that package's history.
+     * Measured on `panates/syncbridge`: `@syncbridge/hl7`'s manifest came back as `C054` from
+     * `packages/common/package.json` - a different package, `@panates-prv/syncbridge-common`, which was
+     * not even deleted in that commit - and following it would have handed hl7 137 commits of another
+     * package's history. A rename (`R`) means the old file is gone, which a copy does not.
+     *
+     * **And a rename counts only where the directory went too** - more than half of the files the old
+     * directory held landing in the new one (`movedShare`). Two manifests are similar enough to pair
+     * when a directory is *split*: in the same repository `packages/builtins` was broken into ten
+     * packages in one commit, git paired its `package.json` with `packages-ext/serialport`'s at
+     * `R052`, and serialport had received 3 of its 43 files. The old directory belongs to no one of
+     * them, so the walk stops there and its history stays the root's - unattributed rather than
+     * guessed. A real move clears this easily: `iomt-connectors` took 101 of its 110 files. */
+    async moveHistory(file) {
+        let stdout;
+        try {
+            ({ stdout } = await execFileAsync('git', ['log', '--follow', '--format=%x00%H', '--name-status', '--', path.relative(this.cwd, file)], { cwd: this.cwd, maxBuffer: 64 * 1024 * 1024 }));
+        }
+        catch {
+            return [];
+        }
+        const moves = [];
+        for (const entry of stdout.split('\0').filter(Boolean)) {
+            const [sha, ...lines] = entry.split(/\r?\n/).filter(Boolean);
+            const [status = '', from, to] = (lines[0] ?? '').split('\t');
+            if (status.startsWith('R') && from && to) {
+                const fromDir = path.posix.dirname(from);
+                const toDir = path.posix.dirname(to);
+                /** Renamed within its own directory: the package did not move. */
+                if (fromDir === toDir)
+                    continue;
+                if ((await this.movedShare(sha.trim(), fromDir, toDir)) <= 0.5)
+                    break;
+                moves.push({ sha: sha.trim(), from: path.join(this.cwd, from), to: path.join(this.cwd, to) });
+            }
+            else if (status.startsWith('C') || status === 'A')
+                break;
+        }
+        return moves;
+    }
+    /**
+     * Of the files `fromDir` held just before `sha`, the share `sha` renamed into `toDir` - `0` to `1`.
+     * Both directories relative to `cwd`, in git's `/` form.
+     */
+    /* The rename list is cached per commit: a commit that moves every package is asked about once per
+     * package, and it is one `git show` however many ask. */
+    async movedShare(sha, fromDir, toDir) {
+        let renames = this._renames.get(sha);
+        if (!renames) {
+            renames = execFileAsync('git', ['show', '-M', '--name-status', '--format=', sha], {
+                cwd: this.cwd,
+                maxBuffer: 64 * 1024 * 1024,
+            }).then(({ stdout }) => stdout
+                .split(/\r?\n/)
+                .map(line => line.split('\t'))
+                .filter(([status, from, to]) => status?.startsWith('R') && from && to)
+                .map(([, from, to]) => ({ from, to })), () => []);
+            this._renames.set(sha, renames);
+        }
+        let held;
+        try {
+            const { stdout } = await execFileAsync('git', ['ls-tree', '-r', '--name-only', `${sha}^`, '--', `${fromDir}/`], {
+                cwd: this.cwd,
+                maxBuffer: 64 * 1024 * 1024,
+            });
+            held = stdout.split(/\r?\n/).filter(Boolean);
+        }
+        catch {
+            return 0;
+        }
+        if (!held.length)
+            return 0;
+        const into = (await renames).filter(r => r.from.startsWith(`${fromDir}/`) && r.to.startsWith(`${toDir}/`)).length;
+        return into / held.length;
+    }
     /** The best common ancestor of `a` and `b` - `undefined` if none exists (unrelated histories,
      *  an invalid ref, ...). */
     async mergeBase(a, b) {

package/utils/status-region.js

@@ -1,5 +1,5 @@
 import colors from 'ansi-colors';
-import { LiveRegion } from './live-region.js';
+import { LiveRegion } from '../core/classes/live-region.js';
 export class StatusRegion {
     label;
     detail;