rman 2.12.0 → 2.13.0

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

@@ -133,6 +133,10 @@ export declare namespace PublishService {
      * `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

@@ -173,6 +173,26 @@ export var PublishService;
         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);
@@ -431,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

@@ -73,6 +73,8 @@ export declare class NpmPublishTarget implements PublishTarget {
     };
     /** 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

@@ -79,6 +79,10 @@ export class NpmPublishTarget {
     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/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,10 +102,54 @@ function statusLabel(status) {
             return '';
     }
 }
-/** Where a package ships, one target name each - grey for a target `publish` would skip it for
- *  (`Item.skippedTargets`), so the column never reads as a promise the release will not keep. */
+/** 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) {
-    return it.publishTargets.map(name => (it.skippedTargets[name] ? colors.gray(name) : colors.green(name))).join(', ');
+    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.
@@ -125,10 +171,13 @@ function publishLabel(it) {
  */
 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));

package/constants.js

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

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

@@ -69,6 +69,11 @@ export interface PublishTarget {
      * 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[]>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "2.12.0",
+  "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/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;
@@ -81,6 +90,10 @@ export declare namespace ListService {
          *  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

@@ -2,6 +2,7 @@ import path from 'path';
 import { Service } from '../core/classes/service.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.**
  *
@@ -36,13 +37,21 @@ export class ListService extends Service {
             /** **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 targets = p === repository.rootPackage && repository.monorepo ? [] : targetsOf(this.app, p);
+            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,
@@ -50,6 +59,8 @@ export class ListService extends Service {
                 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,
@@ -57,6 +68,7 @@ export class ListService extends Service {
                 dependencies: p.dependencies.map(d => d.name),
                 publishTargets: [...publishTargets],
                 skippedTargets,
+                targetLabels,
                 docker: publishTargets.includes('docker') ? p.config.publish?.docker : undefined,
             };
         };
@@ -90,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/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) {