rman 2.0.1 → 2.1.0

package/commands/changelog.command.d.ts

@@ -47,6 +47,23 @@ declare const config: {
         describe: string;
         type: "string";
     };
+    /**
+     * **Default `true`, so the flag that does something is `--no-commit-hash`.** GitHub autolinks a
+     * bare abbreviated sha wherever it renders Markdown inside a repository, so the plain
+     * `(a1b2c3d)` this writes is a link on the page and stays readable in a terminal - which a
+     * hand-built `[a1b2c3d](https://.../commit/a1b2c3d)` would not be, and which rman could not build
+     * anyway without knowing the forge.
+     *
+     * `'both'` rather than config-only: it is a lasting preference, and it is also the one thing a
+     * caller may want to turn off for a single run - `github-release` bodies are rendered in the same
+     * repository, but notes pasted somewhere else lose the autolinking and keep the noise.
+     */
+    commitHash: {
+        target: "both";
+        cliName: string;
+        describe: string;
+        type: "boolean";
+    };
     tagPattern: {
         target: "config";
         describe: string;
@@ -208,6 +225,23 @@ declare const changelogCommand: (app: import("../index.js").RmanApplication) =>
             describe: string;
             type: "string";
         };
+        /**
+         * **Default `true`, so the flag that does something is `--no-commit-hash`.** GitHub autolinks a
+         * bare abbreviated sha wherever it renders Markdown inside a repository, so the plain
+         * `(a1b2c3d)` this writes is a link on the page and stays readable in a terminal - which a
+         * hand-built `[a1b2c3d](https://.../commit/a1b2c3d)` would not be, and which rman could not build
+         * anyway without knowing the forge.
+         *
+         * `'both'` rather than config-only: it is a lasting preference, and it is also the one thing a
+         * caller may want to turn off for a single run - `github-release` bodies are rendered in the same
+         * repository, but notes pasted somewhere else lose the autolinking and keep the noise.
+         */
+        commitHash: {
+            target: "both";
+            cliName: string;
+            describe: string;
+            type: "boolean";
+        };
         tagPattern: {
             target: "config";
             describe: string;

package/commands/changelog.command.js

@@ -62,6 +62,29 @@ const config = {
             "{{package}}/{{version}} placeholders are that file's content, not config expressions.",
         type: 'string',
     },
+    /**
+     * **Default `true`, so the flag that does something is `--no-commit-hash`.** GitHub autolinks a
+     * bare abbreviated sha wherever it renders Markdown inside a repository, so the plain
+     * `(a1b2c3d)` this writes is a link on the page and stays readable in a terminal - which a
+     * hand-built `[a1b2c3d](https://.../commit/a1b2c3d)` would not be, and which rman could not build
+     * anyway without knowing the forge.
+     *
+     * `'both'` rather than config-only: it is a lasting preference, and it is also the one thing a
+     * caller may want to turn off for a single run - `github-release` bodies are rendered in the same
+     * repository, but notes pasted somewhere else lose the autolinking and keep the noise.
+     */
+    /* **No `default: true` here, and that is the trap `unreleased` already avoids** - the default
+     * lives in `withCommitHash`. Declared as a yargs default, an omitted flag arrives as `true`
+     * rather than `undefined`, so the flag would win over `.rmanrc changelog.commitHash` on every run
+     * and the config key could never turn it off. The precedence rule everywhere is *the flag wins
+     * when it was given*, which needs an unset flag to stay unset. */
+    commitHash: {
+        target: 'both',
+        cliName: 'commit-hash',
+        describe: "Append each commit's short sha to its line (default true) - pass --no-commit-hash for " +
+            'notes that are read outside the repository, where GitHub does not autolink it',
+        type: 'boolean',
+    },
     tagPattern: {
         target: 'config',
         describe: "The release tag naming scheme each package's changelog boundary is detected from - " +
@@ -141,6 +164,7 @@ const changelogCommand = registerCommand(app => {
                 version: args.releaseVersion,
                 startingAt: args.startingAt,
                 unreleased: args.unreleased,
+                commitHash: args.commitHash,
             };
             const changelog = app.getService('changelog');
             const entries = write ? await changelog.generateToFile(options) : await changelog.getEntries(options);

package/constants.js

@@ -1 +1 @@
-export const version = '2.0.1';
+export const version = '2.1.0';

package/core/classes/repository.js

@@ -491,7 +491,11 @@ export class Repository extends Package {
             app.publishTargets.add(target);
         }
         const packages = workspace.packages;
-        const repo = new Repository(app, rootDir, packages.length > 0, packages, from, workspace.rootPackage.platform);
+        /** `workspace.monorepo`, not `packages.length > 0` again: the workspace already had to answer
+         *  this during the cascade - it is what decides whether a `"[glob]"` speaks for the root - and
+         *  two copies of the derivation could disagree silently, resolving a config under one answer
+         *  and building the package list under the other. */
+        const repo = new Repository(app, rootDir, workspace.monorepo, packages, from, workspace.rootPackage.platform);
         repo._adopt(workspace);
         app.attachRepository(repo);
         return Repository._init(repo);

package/core/classes/workspace.d.ts

@@ -45,6 +45,13 @@ export declare class Workspace {
     static create(rootDir: string, options: Workspace.Options): Promise<Workspace>;
     /** Use {@link Workspace.create}. */
     protected constructor(rootDir: string, options: Workspace.Options);
+    /**
+     * Whether the walk found packages *below* the root - i.e. whether this is a monorepo.
+     *
+     * `false` means the root is the repository's one and only package, which is what decides whether
+     * a `"[glob]"` selector speaks for it (see {@link Workspace._speaksFor}).
+     */
+    get monorepo(): boolean;
     /** The package at a directory, root included, or `undefined` for one that holds none. */
     packageAt(dirname: string): Package | undefined;
     /** The whole resolution, in the one order the steps admit. */
@@ -109,8 +116,8 @@ export declare class Workspace {
     /**
      * Whether one selector block speaks for this package.
      *
-     * `"[/]"` asks only whether this *is* the root. Everything else matches packages **below** the
-     * root and never the root itself, which is addressed structurally or not at all.
+     * `"[/]"` asks only whether this *is* the root. A `"[glob]"` matches packages **below** the root -
+     * and, in a repository that has none, the root itself, because there it *is* the one package.
      */
     protected _speaksFor(scope: ConfigReader.ParsedSelector['scope'], test: (value: string) => boolean, audience: Workspace.Audience): boolean;
     /**

package/core/classes/workspace.js

@@ -74,6 +74,24 @@ export class Workspace {
         this.plugins = [...(options.plugins ?? [])];
         this.platforms = [...(options.platforms ?? [])];
     }
+    /**
+     * Whether the walk found packages *below* the root - i.e. whether this is a monorepo.
+     *
+     * `false` means the root is the repository's one and only package, which is what decides whether
+     * a `"[glob]"` selector speaks for it (see {@link Workspace._speaksFor}).
+     */
+    /* **One derivation, read from two places.** `Repository.create` computed `packages.length > 0`
+     * itself and passed it in as the `monorepo` constructor argument; `_speaksFor` now needs the same
+     * fact *during* the cascade, which runs before any `Repository` exists. Two copies of a one-line
+     * derivation is two places to disagree, and the disagreement would be silent - a config resolved
+     * under one answer and a command's package list built under the other. `Repository.create` reads
+     * this getter now.
+     *
+     * Safe to ask at cascade time because `_discover` has already run: `_init` walks the tree first
+     * and only then resolves selectors and configs, so `packages` is final by the time either asks. */
+    get monorepo() {
+        return this.packages.length > 0;
+    }
     /** The package at a directory, root included, or `undefined` for one that holds none. */
     packageAt(dirname) {
         const resolved = path.resolve(dirname);
@@ -369,17 +387,47 @@ export class Workspace {
     /**
      * Whether one selector block speaks for this package.
      *
-     * `"[/]"` asks only whether this *is* the root. Everything else matches packages **below** the
-     * root and never the root itself, which is addressed structurally or not at all.
+     * `"[/]"` asks only whether this *is* the root. A `"[glob]"` matches packages **below** the root -
+     * and, in a repository that has none, the root itself, because there it *is* the one package.
      */
-    /* **A glob never matching the root removes two traps at once**: `"[my-*]"` cannot quietly pick up
-     * a repository whose root package is called `my-repo`, and `"[*]"` cannot hand a package-shaped
-     * setting to a root with no build directory to apply it to. Neither trap exists for a platform
-     * block - `platform:node` is not a name and cannot match by accident, and it is not a catch-all -
-     * so **a platform link answers about the root like any other package**, and what keeps a plain
-     * `"[platform:node]"` off the root is `_matchingSelectors`' chain rule rather than a refusal here.
-     * Asking `isRoot` first was what made `"[platform:node]" > "[/]"` unanswerable: the pair says *the
-     * root, when it is a node package*, and the short-circuit never let the platform question be put.
+    /* **A glob is held off a MONOREPO root, and only a monorepo root** - which is narrower than the
+     * rule this replaces and is the whole of the change. Both justifications for the old blanket
+     * refusal are statements about a monorepo root, and neither survives being read in a
+     * single-package repository:
+     *
+     *   - `"[my-*]"` must not quietly pick up a repository whose root package is called `my-repo`.
+     *     That is an *accidental* name collision between a container and the things it contains.
+     *     With nothing contained, the root is not a container that happens to share a name shape -
+     *     it is the package, and `"[postgrejs]"` naming it is the author saying what they mean.
+     *   - `"[*]"` must not hand a package-shaped setting to a root with no build directory to apply
+     *     it to. A single-package root *has* the build directory: it is where the package is built.
+     *
+     * What the old rule cost, measured on `panates/postgrejs` before this: `@panates/rman-preset`
+     * declares its whole package block under `"[platform:node]" > "[*]"` - `run.build`,
+     * `publish.npm.directory`, `version.stamp`, the build directory's `clean.include` - and *none* of
+     * it reached that repository. `rman build` answered `No package defines a "build" script.` and
+     * `rman config` showed the four keys simply absent, with nothing reporting that a block had
+     * matched nobody. The workaround would have been for every single-package repository to restate
+     * the preset's block under `"[/]"`, which is the duplication a shared preset exists to remove -
+     * and it is not even writable in YAML, since two of those values are JavaScript functions the
+     * preset keeps to itself.
+     *
+     * **`"[/]"` still means the root and is still the right spelling for a repo-wide setting**, so in
+     * a single-package repository both selectors reach the one package and are layered in declaration
+     * order like any two siblings. That overlap is not a conflict to resolve: `"[/]"` says *the
+     * repository* and `"[*]"` says *its packages*, and in a repository of one those are the same
+     * object - which is the fact this rule finally states.
+     *
+     * Neither trap exists for a platform block - `platform:node` is not a name and cannot match by
+     * accident, and it is not a catch-all - so **a platform link answers about the root like any other
+     * package**, and what keeps a plain `"[platform:node]"` off the root is `_matchingSelectors`'
+     * chain rule rather than a refusal here. Asking `isRoot` first was what made
+     * `"[platform:node]" > "[/]"` unanswerable: the pair says *the root, when it is a node package*,
+     * and the short-circuit never let the platform question be put.
+     *
+     * **The CLI moves with this, and has to**: `--scope '*'` and `"[*]"` are documented as the same
+     * set, so `package-filter.ts`'s `selector()` carries the identical clause. Changing one alone
+     * would make a repository's config and its `--scope` disagree about what a package is.
      *
      * A package no technology claimed carries `basePlatform`, whose name is `''`, so it matches no
      * platform block at all - `parseSelector`'s test refuses an empty name rather than letting an
@@ -389,7 +437,9 @@ export class Workspace {
             return audience.isRoot;
         if (scope === 'platform')
             return test(audience.platform);
-        return !audience.isRoot && audience.selector !== undefined && test(audience.selector);
+        if (audience.isRoot && this.monorepo)
+            return false;
+        return audience.selector !== undefined && test(audience.selector);
     }
     /**
      * The platform that claims a directory - the one its config names, or the first loaded platform

package/package.json

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

package/services/changelog.service.d.ts

@@ -24,8 +24,8 @@ export declare class ChangelogService extends Service {
      * outside every package) - unless it's broad enough to count as a repo-wide change (see
      * `BROAD_COMMIT_THRESHOLD`/`ownersOf`), in which case it goes to root alone instead of being
      * repeated verbatim across most of the repository. Subject lines are grouped ✨ Features/🐛 Bug
-     * Fixes/🔧 Other Changes on a best-effort Conventional Commits read; anything that doesn't parse
-     * just lands in Other Changes as-is, so a repo that doesn't follow that convention still gets a
+     * Fixes/💬 General Changes on a best-effort Conventional Commits read; anything that doesn't parse
+     * just lands in General Changes as-is, so a repo that doesn't follow that convention still gets a
      * usable list. `.rmanrc changelog.ignoreTypes` (cascaded, e.g. `[chore, dev]`) drops commits of
      * those types entirely instead - see `ignoreTypesConfig`. A release marker - a bare version-bump
      * commit (`"6.0.1"`), or any of the messages `version` itself writes - is always dropped
@@ -104,6 +104,9 @@ export declare namespace ChangelogService {
          *  omitted, and `true` when neither says. A caller passing `version` always gets it, since that
          *  names the release being cut; see `resolveUnreleased`. */
         unreleased?: boolean;
+        /** Whether each line ends with its commit's short sha - `.rmanrc changelog.commitHash` when
+         *  omitted, and `true` when neither says. See `withCommitHash`. */
+        commitHash?: boolean;
     }
     /** One package's (root included) generated changelog entry - what `getEntries`/`generate`
      *  return. */

package/services/changelog.service.js

@@ -48,8 +48,8 @@ export class ChangelogService extends Service {
      * outside every package) - unless it's broad enough to count as a repo-wide change (see
      * `BROAD_COMMIT_THRESHOLD`/`ownersOf`), in which case it goes to root alone instead of being
      * repeated verbatim across most of the repository. Subject lines are grouped ✨ Features/🐛 Bug
-     * Fixes/🔧 Other Changes on a best-effort Conventional Commits read; anything that doesn't parse
-     * just lands in Other Changes as-is, so a repo that doesn't follow that convention still gets a
+     * Fixes/💬 General Changes on a best-effort Conventional Commits read; anything that doesn't parse
+     * just lands in General Changes as-is, so a repo that doesn't follow that convention still gets a
      * usable list. `.rmanrc changelog.ignoreTypes` (cascaded, e.g. `[chore, dev]`) drops commits of
      * those types entirely instead - see `ignoreTypesConfig`. A release marker - a bare version-bump
      * commit (`"6.0.1"`), or any of the messages `version` itself writes - is always dropped
@@ -143,7 +143,7 @@ export class ChangelogService extends Service {
                 const ownCommits = dropVersionBumps(segment.commits).filter(c => ownersOf(repository, c).has(pkg));
                 if (!ownCommits.length)
                     continue;
-                const sections = groupCommits(ownCommits.map(c => c.subject), ignoreTypesConfig(pkg), titles, order);
+                const sections = groupCommits(ownCommits, ignoreTypesConfig(pkg), titles, order, withCommitHash(pkg, options));
                 // every commit could have been dropped by ignoreTypes - skip this package's entry entirely
                 // rather than rendering a heading with nothing real underneath it.
                 if (!sections.length)
@@ -168,9 +168,9 @@ export class ChangelogService extends Service {
     }
 }
 /** `.rmanrc changelog.ignoreTypes` (cascaded, per-package overridable) - Conventional Commits
- *  `type`s to drop entirely (e.g. `[chore, dev]`), not just fold into "Other Changes". Only
+ *  `type`s to drop entirely (e.g. `[chore, dev]`), not just fold into "General Changes". Only
  *  applies to commits that actually parse as `type: ...` - a non-conventional message always
- *  still lands in Other Changes, since it has no `type` to match against. */
+ *  still lands in General Changes, since it has no `type` to match against. */
 function ignoreTypesConfig(pkg) {
     const v = pkg.config?.changelog?.ignoreTypes;
     return new Set(Array.isArray(v) ? v.map(t => String(t).toLowerCase()) : []);
@@ -204,36 +204,62 @@ function resolveTitles(pkg) {
  *
  * **The type prefix is stripped for every section, not just two.** It used to be `push(line)` for
  * `feat`/`fix` and `push(subject)` for everything else, so Features read `- the first feature`
- * while Other Changes read `- chore: write changelog` - the heading naming the type and the bullet
- * repeating it. With every type able to have a heading of its own that asymmetry has no defence
- * left. A subject that is not Conventional Commits at all has no prefix to strip and is kept whole.
+ * while General Changes read `- chore: write changelog` - the heading naming the type and the
+ * bullet repeating it. With every type able to have a heading of its own that asymmetry has no
+ * defence left. A subject that is not Conventional Commits at all has no prefix to strip and is
+ * kept whole.
  */
-function groupCommits(subjects, ignoreTypes, titles, order) {
+/* **A message repeated inside one section is written once.** Real histories hold runs of identical
+ * subjects - measured on `panates/postgrejs`, whose v2.22.1 entry read `Updated config` five times
+ * under one heading - and the repetition states nothing the first line did not. Deduplicated **per
+ * section**, not per entry: `feat: x` and `fix: x` are different claims that land under different
+ * headings, and collapsing those would lose a fact rather than a repetition.
+ *
+ * **Keyed on the message, before the sha is appended**, which is the whole subtlety: with the sha on
+ * the line every duplicate is textually unique and the check would never fire. So the survivor keeps
+ * the *first* commit's sha - and since `listCommits` returns oldest-first, that is the earliest of
+ * the run. The others are dropped entirely, which is the point rather than a cost: the entry says
+ * what changed, and `git log` says how many times it was committed.
+ *
+ * **The sha is written plain, never as a Markdown link.** GitHub autolinks an abbreviated sha
+ * wherever it renders Markdown inside the repository, so `(a1b2c3d)` is already a link on the page
+ * and still readable in a terminal; a hand-built URL would need to know the forge, which nothing
+ * here does. Seven characters because that is what `git log --abbrev-commit` and GitHub both show.
+ */
+function groupCommits(commits, ignoreTypes, titles, order, commitHash) {
     const CATCH_ALL = '*';
     const byTitle = new Map();
+    const seenByTitle = new Map();
     const titleFor = (type) => titles.get(type) ?? titles.get(CATCH_ALL) ?? DEFAULT_TITLES.get(CATCH_ALL);
-    const push = (title, line) => {
+    const push = (title, message, sha) => {
+        let seen = seenByTitle.get(title);
+        if (!seen)
+            seenByTitle.set(title, (seen = new Set()));
+        if (seen.has(message))
+            return;
+        seen.add(message);
+        const line = commitHash ? `${message} (${sha.slice(0, SHORT_SHA_LENGTH)})` : message;
         const lines = byTitle.get(title);
         if (lines)
             lines.push(line);
         else
             byTitle.set(title, [line]);
     };
-    for (const subject of subjects) {
+    for (const { subject, sha } of commits) {
         const parsed = ConventionalCommitsService.parseSubject(subject);
         if (!parsed) {
-            push(titleFor(CATCH_ALL), subject);
+            push(titleFor(CATCH_ALL), subject, sha);
             continue;
         }
         const { type, scope, description } = parsed;
         if (ignoreTypes.has(type))
             continue;
-        push(titleFor(type), scope ? `**${scope}:** ${description}` : description);
+        push(titleFor(type), scope ? `**${scope}:** ${description}` : description, sha);
     }
     /**
      * Only a type with a heading of its own takes a position. A type nobody named resolves to the
      * catch-all, so ordering by it would drag the catch-all to wherever that type was listed -
-     * measured: `sortTitles: ['docs', 'fix', 'feat']` with no `docs` heading put "Other Changes"
+     * measured: `sortTitles: ['docs', 'fix', 'feat']` with no `docs` heading put "General Changes"
      * first and swallowed the sections after it.
      */
     const ordered = [...new Set(order.filter(t => t !== CATCH_ALL && titles.has(t)).map(titleFor))];
@@ -286,11 +312,57 @@ function legacyBuckets(sections, titles) {
 }
 /** `feat`/`fix`/everything else, which is what rman shipped before `changelog.titles` existed and
  *  so is what a repository that sets nothing still gets, wording and order alike. */
+/**
+ * The heading each commit type is listed under, and - because `resolveOrder` falls back to
+ * `titles.keys()` - the order the sections come out in. `.rmanrc changelog.titles` is merged over
+ * this **per key**, so a repository renaming one keeps the rest and keeps its position.
+ */
+/* **Three entries was too few, and the measurement is what says so.** `feat`, `fix` and a catch-all
+ * were all rman named, so every other type fell into one heap: counted across four of this
+ * organization's repositories (rman, postgrejs, panates-javascript, syncbridge-public), that heap
+ * held 194 `chore`, 86 `docs`, 68 `refactor`, 29 `test`, 27 `ci` and 24 `perf` - more commits than
+ * the two named types put together, under a heading that says only "not one of the two".
+ *
+ * The set is Conventional Commits' own standard types and stops there. `dev` (32 across the same
+ * four) and `bench` (9) are this organization's inventions, and a repository names those in its own
+ * `changelog.titles` - or a shared preset does it once for all of them. rman shipping a heading for
+ * a type no convention defines would be guessing on everyone else's behalf.
+ *
+ * **These add sections; they do not hide anything.** `ignoreTypes` is what drops a type, and it
+ * stays the only thing that does - which is the one place this parts from conventional-changelog,
+ * whose default preset silently hides `chore`, `ci`, `build`, `style` and `test`. A changelog that
+ * quietly omits a third of the history is the failure mode worth avoiding; a reader who does not
+ * want those sections can say so in one key.
+ *
+ * Order: Features, Bug Fixes, Performance and Reverts first, as conventional-changelog has them -
+ * the four a reader is looking for - then the rest, then the catch-all, which `groupCommits` pins
+ * last whatever anyone writes.
+ *
+ * **Every emoji here is checked for U+FE0F and none carries it.** A variation selector survives
+ * github-slugger, so `### ♻️ Refactoring` gets an anchor nobody types by hand and every link to it
+ * silently lands at the top of the page - the trap already recorded for `⬆️`. That is why refactor
+ * is `🔧` (U+1F527, free now that the catch-all is `💬`) rather than `♻️`, and ci is `🤖` rather
+ * than `⚙️`.
+ *
+ * "General Changes", not "Other Changes", for the catch-all: even with eleven named types it holds
+ * whatever convention a repository invented for itself, and "Other" reads as the leftovers after
+ * the interesting part. */
 const DEFAULT_TITLES = new Map([
     ['feat', '✨ Features'],
     ['fix', '🐛 Bug Fixes'],
-    ['*', '🔧 Other Changes'],
+    ['perf', '⚡ Performance and Optimizations'],
+    ['revert', '⏪ Reverts'],
+    ['refactor', '🔧 Refactoring'],
+    ['docs', '📚 Documentation'],
+    ['test', '🧪 Tests'],
+    ['build', '📦 Build System'],
+    ['ci', '🤖 Continuous Integration'],
+    ['chore', '🧹 Chores'],
+    ['style', '🎨 Code Style'],
+    ['*', '💬 General Changes'],
 ]);
+/** What `git log --abbrev-commit` prints and what GitHub autolinks. */
+const SHORT_SHA_LENGTH = 7;
 function bulletList(lines) {
     return lines.map(l => `- ${l}`).join('\n');
 }
@@ -353,6 +425,12 @@ function resolveUnreleased(pkg, options) {
     const cfg = pkg.config?.changelog?.unreleased;
     return options.unreleased ?? (typeof cfg === 'boolean' ? cfg : true);
 }
+/** Whether each line carries its commit's short sha - `.rmanrc changelog.commitHash`, or the flag,
+ *  which wins as everywhere. Defaults to `true`; `--no-commit-hash` is what turns it off. */
+function withCommitHash(pkg, options) {
+    const cfg = pkg.config?.changelog?.commitHash;
+    return options.commitHash ?? (typeof cfg === 'boolean' ? cfg : true);
+}
 /**
  * **Where this package's changelog begins** - `.rmanrc changelog.startingAt`, or the CLI flag,
  * which wins as everywhere.

package/services/conventional-commits.service.d.ts

@@ -13,7 +13,7 @@
 export declare namespace ConventionalCommitsService {
     /**
      * `type(scope): description`, optionally with a `!` breaking-change marker - Conventional
-     * Commits' subject-line shape. Anything that doesn't match falls into "Other Changes" as-is (for
+     * Commits' subject-line shape. Anything that doesn't match falls into "General Changes" as-is (for
      * changelog entries) or defaults to a patch-level change (for version bump severity) - see
      * `parseSubject`.
      */

package/services/conventional-commits.service.js

@@ -14,7 +14,7 @@ export var ConventionalCommitsService;
 (function (ConventionalCommitsService) {
     /**
      * `type(scope): description`, optionally with a `!` breaking-change marker - Conventional
-     * Commits' subject-line shape. Anything that doesn't match falls into "Other Changes" as-is (for
+     * Commits' subject-line shape. Anything that doesn't match falls into "General Changes" as-is (for
      * changelog entries) or defaults to a patch-level change (for version bump severity) - see
      * `parseSubject`.
      */

package/utils/package-filter.d.ts

@@ -46,12 +46,17 @@ export interface PackageFilterOptions {
 /**
  * **`--scope /` is the repository's own root package**, the one selector that is not a glob.
  *
- * The same `/` `.rmanrc`'s `"[/]"` block uses, and for the same reason stated there: *the root is
- * never selected by name.* A glob matches package names, and a name can be anything - so
+ * The same `/` `.rmanrc`'s `"[/]"` block uses, and for the same reason stated there: *a monorepo's
+ * root is never selected by name.* A glob matches package names, and a name can be anything - so
  * `--scope rman-repo` happened to work (measured) while being exactly the name-based addressing the
  * config selectors were redesigned to remove. `/` is structural, cannot collide with a package
  * (nothing can be named it), and gives "the root" one spelling across config and CLI.
  *
+ * **In a single-package repository a glob does reach the root**, because there it is not a container
+ * that happens to have a name - it is the one package, and `--scope '*'` meaning "no packages" was
+ * the same silent emptiness `"[*]"` had in a `.rmanrc`. `/` still selects it, so nothing that worked
+ * stops working; see `Workspace._speaksFor`, which carries the identical clause.
+ *
  * Accepted by `--ignore` too. The asymmetry would be the thing to remember, and `--ignore /` -
  * every package but the root - is a real thing to want of `clean`.
  *

package/utils/package-filter.js

@@ -2,12 +2,17 @@ import micromatch from 'micromatch';
 /**
  * **`--scope /` is the repository's own root package**, the one selector that is not a glob.
  *
- * The same `/` `.rmanrc`'s `"[/]"` block uses, and for the same reason stated there: *the root is
- * never selected by name.* A glob matches package names, and a name can be anything - so
+ * The same `/` `.rmanrc`'s `"[/]"` block uses, and for the same reason stated there: *a monorepo's
+ * root is never selected by name.* A glob matches package names, and a name can be anything - so
  * `--scope rman-repo` happened to work (measured) while being exactly the name-based addressing the
  * config selectors were redesigned to remove. `/` is structural, cannot collide with a package
  * (nothing can be named it), and gives "the root" one spelling across config and CLI.
  *
+ * **In a single-package repository a glob does reach the root**, because there it is not a container
+ * that happens to have a name - it is the one package, and `--scope '*'` meaning "no packages" was
+ * the same silent emptiness `"[*]"` had in a `.rmanrc`. `/` still selects it, so nothing that worked
+ * stops working; see `Workspace._speaksFor`, which carries the identical clause.
+ *
  * Accepted by `--ignore` too. The asymmetry would be the thing to remember, and `--ignore /` -
  * every package but the root - is a real thing to want of `clean`.
  *
@@ -297,5 +302,12 @@ function selector(value) {
      *  `/` above already is. It was `pkg.name`, and the two coincide for every Node repository; a
      *  package having a name at all is an ecosystem's promise, and a repository can assign a selector
      *  where its own does not offer one. */
-    return pkg => (pkg.isRoot ? wantsRoot : globs.length > 0 && micromatch.isMatch(pkg.selector, globs));
+    /** **A glob reaches the root in a single-package repository**, exactly as `"[*]"` does in a
+     *  `.rmanrc` - the two are documented as the same set, so they move together or a repository's
+     *  config and its `--scope` disagree about what a package is. In a monorepo the root is still
+     *  addressed by `/` alone; there it is a container that happens to have a name, and a glob picking
+     *  it up by that name is the trap `/` was introduced to remove. `pkg.repository` is safe to read
+     *  under `isRoot`, which is `false` until `Repository.create` assigns it. */
+    const matchesGlob = (pkg) => globs.length > 0 && micromatch.isMatch(pkg.selector, globs);
+    return pkg => (pkg.isRoot ? wantsRoot || (!pkg.repository.monorepo && matchesGlob(pkg)) : matchesGlob(pkg));
 }