rman-node 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Panates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,149 @@
+# rman-node
+
+Node.js support for [rman](https://github.com/panates/rman).
+
+rman's core is about repositories - packages, versions, changelogs, releases, branches. Anything
+that only means something because the repository happens to be a Node one lives here, so the core
+stays usable by a repository in any language.
+
+Full API reference: **[docs/node.md](https://github.com/panates/rman/blob/main/docs/node.md)**.
+
+## Install
+
+```bash
+npm i -D rman-node
+```
+
+```yaml
+# .rmanrc.yml
+plugins: ['rman-node']
+```
+
+A plugin that cannot be loaded is an error, not a skip: silently losing `rman publish` is worse
+than not starting.
+
+## Commands
+
+These three commands do not exist without this package - `rman clean` is `Unknown argument: clean`
+in a repository that names no plugin.
+
+### `rman publish`
+
+Publishes every package to its configured registry - `npm` by default, or whatever each package's
+own `.rmanrc "publish.target"` says (`"npm"`, `"docker"`, or both). Each target decides for itself
+whether the current version is already out there: `npm view` on the npm side, `docker manifest
+inspect` on the docker side.
+
+```bash
+rman publish                              # show the plan, then ask for confirmation
+rman publish --yes                        # publish immediately, no confirmation
+rman publish --dry-run                    # only show the plan, never publish
+rman publish --access public              # required for a new scoped package
+rman publish --tag next
+rman publish --otp 123456
+rman publish --registry https://registry.example.com --userconfig ./ci.npmrc
+rman publish --package-manager pnpm
+rman publish --target docker              # only the packages configured for the "docker" target
+```
+
+A `"workspace:*"`/`"workspace:^"`/`"workspace:~"` dependency range is automatically rewritten to a
+real, registry-consumable range immediately before each package's publish, and restored right
+after - see [docs/node.md#publishservice](https://github.com/panates/rman/blob/main/docs/node.md#publishservice).
+
+A package opts into building/pushing a Docker image via `.rmanrc "publish.target": ["docker"]` plus
+a `"publish.docker"` block (`image`, `platforms`, `buildContexts`, `buildArgs`, ...) - see
+[docs/cli/publish.md](https://github.com/panates/rman/blob/main/docs/cli/publish.md#docker-publishing-publishdocker).
+
+### `rman ci`
+
+Deletes `node_modules` and any lockfile in every package (or runs the package's own `"ci"` script
+instead, if it defines one), then installs once at the root.
+
+```bash
+rman ci
+rman ci --package-manager pnpm
+```
+
+### `rman clean`
+
+Removes compiled TypeScript output (`.js`/`.js.map`/`.d.ts` under `src`/`test`, plus any
+`*.tsbuildinfo`) and whatever `.rmanrc clean.include`/`clean.exclude` configures. Never touches
+`node_modules` - that's `ci`'s job.
+
+```bash
+rman clean
+rman clean --dry-run              # preview what would be removed
+```
+
+Every one of its built-in behaviours is a **TypeScript** fact, which is why it is here and not in
+the core: nothing in it would fire for a Cargo or Go repository, and both ship a `clean` of their
+own. A `.d.ts` with no matching `.ts` beside it is left alone - that is a hand-written declaration,
+not build output.
+
+## Config keys
+
+Three `.rmanrc` keys come from this package, and they reach rman's own `RmanConfig` type by
+declaration merging - so `pkg.config.clean` is typed where it is read, with no cast:
+
+| Key | Level | |
+| --- | --- | --- |
+| `packageManager` | root only | Which package manager `ci`/`publish` shell out to, and whose version `info` reports. Default `npm`. |
+| `clean` | per package | `include`/`exclude` globs beyond TypeScript's own output, plus `skip`. |
+| `publish.directory` | per package | Where this package's publishable output lives, relative to its own directory. |
+
+`RmanNodeConfig` is the name a config author annotates with, and importing its `defineConfig` is
+what carries the augmentation:
+
+```js
+// .rmanrc.mjs
+import { defineConfig } from 'rman-node';
+
+export default defineConfig({
+  plugins: ['rman-node'],
+  packageManager: 'pnpm',
+  '[ws:*]': { clean: { include: 'build' }, publish: { directory: 'build' } },
+});
+```
+
+The JSON and YAML forms of the config carry no type - rman ships no JSON Schema, because a schema
+cannot describe keys a plugin contributes. See
+[docs/rman.md#editor-support-types](https://github.com/panates/rman/blob/main/docs/rman.md#editor-support-types).
+
+## Seams and augmentations
+
+Beyond the commands, this package answers the questions rman's core deliberately has no answer to:
+what a package *is* (`package.json`), which directories are packages (`workspaces`), how a version
+is planned, what `pre<script>`/`post<script>` mean, and that `node_modules/.bin` belongs on a child
+process's PATH. Without it a repository has **no manifest reader at all** - which is the point:
+another ecosystem supplies its own through the same seams rather than working around npm's.
+
+Some core behaviour is neutral by default and this package turns it on, because installing it is
+itself the statement that the repository is a Node one.
+
+**`SystemInfo`** (`rman info`): the core service asks about a package manager only when told to - a
+repository in another language reporting "npm: Not Found" is a wrong answer, not a missing feature.
+This package makes npm the default and adds its own version to the report:
+
+```
+# without the plugin          # with it
+ Binaries:                     Binaries:
+    Node : 24.15.0                Node       : 24.15.0
+                                  npm        : 11.12.1
+                               npmPackages:
+                                  rman-node : ...
+                                  rman       : ...
+```
+
+`.rmanrc "packageManager"` still decides *which* one; the augmentation only decides that there is
+one at all.
+
+## Not here
+
+**Docker publishing stayed in the core** - any language's project can publish an image. What is
+still wrong is that `publish` is what *drives* it, so a non-Node repository has to install this
+plugin to reach `publish --target docker`. Fixing that means making a publish target something a
+plugin contributes to a core `publish`.
+
+## Licence
+
+MIT

package/augmentation/manifest.augmentation.d.ts

@@ -0,0 +1,17 @@
+import { type ManifestProvider } from 'rman';
+/**
+ * `package.json` as rman's manifest: where an npm package's name and version are written.
+ *
+ * This is the deepest npm assumption that used to be in rman's core - `Package.name`,
+ * `Package.version`, `Package.json` and `Package.isPrivate` all read this file directly, which
+ * meant every command that asked a package what it was called was asking npm.
+ *
+ * The version scheme is left unset, so packages get the core's semver default: npm versions *are*
+ * semver, and saying so again here would only be a second place for the two to disagree.
+ */
+export declare const packageJsonManifest: ManifestProvider;
+/** npm's four dependency fields. Was `rman`'s `DEPENDENCY_KEYS`, which made the core carry npm's
+ *  field names - `publish` imports it from here now. */
+export declare const DEPENDENCY_KEYS: readonly ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+/** Registers the provider with rman. Called by the plugin entry point, once. */
+export declare function augmentManifest(): void;

package/augmentation/manifest.augmentation.js

@@ -0,0 +1,129 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Manifest, stampVersionConstant } from 'rman';
+import { npmViewVersion } from '../utils/npm-view.js';
+import { parseWorkspaceRange } from '../utils/workspace-range.js';
+/**
+ * `package.json` as rman's manifest: where an npm package's name and version are written.
+ *
+ * This is the deepest npm assumption that used to be in rman's core - `Package.name`,
+ * `Package.version`, `Package.json` and `Package.isPrivate` all read this file directly, which
+ * meant every command that asked a package what it was called was asking npm.
+ *
+ * The version scheme is left unset, so packages get the core's semver default: npm versions *are*
+ * semver, and saying so again here would only be a second place for the two to disagree.
+ */
+export const packageJsonManifest = {
+    /** The ecosystem, not the file - this is what every package it reads reports as
+     *  `pkg.provider === 'node'`. `fileName` below already says `package.json`. */
+    name: 'node',
+    fileName: 'package.json',
+    read(dir) {
+        const file = path.join(dir, 'package.json');
+        if (!fs.existsSync(file))
+            return undefined;
+        const raw = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        return {
+            /** A `package.json` with no `name` is unusual but legal, and `info` prints such a package
+             *  rather than refusing it - so the directory name stands in, as it does for a package with
+             *  no manifest at all. */
+            name: typeof raw?.name === 'string' && raw.name ? raw.name : path.basename(dir),
+            version: typeof raw?.version === 'string' && raw.version ? raw.version : '0.0.0',
+            private: !!raw?.private,
+            raw: raw ?? {},
+        };
+    },
+    /**
+     * npm's four dependency fields, and only the entries naming a package of this repository -
+     * an external dependency is not an edge in rman's graph.
+     *
+     * Matched by name, which is npm's own identifier and unique by construction; an ecosystem where
+     * that does not hold resolves its own way, which is why this is the provider's job.
+     */
+    dependencies(manifest, candidates) {
+        const declared = Object.assign({}, ...DEPENDENCY_KEYS.map(key => manifest.raw[key]));
+        const byName = new Map(candidates.map(p => [p.name, p]));
+        const result = [];
+        for (const name of Object.keys(declared)) {
+            const pkg = byName.get(name);
+            if (pkg && !result.includes(pkg))
+                result.push(pkg);
+        }
+        return result;
+    },
+    /** npm's `@scope/name`. A name with no `/` has no scope and is its own unscoped form; the
+     *  *last* `/` splits it, so `@scope/a/b` keeps `@scope/a` as the scope the registry would. */
+    splitName(name) {
+        const at = name.lastIndexOf('/');
+        return at > 0 ? { scope: name.slice(0, at), unscopedName: name.slice(at + 1) } : { unscopedName: name };
+    },
+    /**
+     * Rewrites a sibling's range in all four fields after it was bumped.
+     *
+     * **A bare `"workspace:*"`/`"^"`/`"~"` selector is left alone**, and that is the load-bearing
+     * case: it resolves to the dependency's *current* version at publish time (see
+     * `resolveWorkspaceRange`), so rewriting it would replace a live reference with a frozen one.
+     * Only an explicit version after `workspace:` needs bumping, like a plain range.
+     */
+    updateDependencyVersions(manifest, bumped) {
+        const versionByName = new Map([...bumped].map(([pkg, version]) => [pkg.name, version]));
+        for (const depKey of DEPENDENCY_KEYS) {
+            const deps = manifest.raw[depKey];
+            if (!deps)
+                continue;
+            for (const depName of Object.keys(deps)) {
+                const to = versionByName.get(depName);
+                if (!to)
+                    continue;
+                const workspace = parseWorkspaceRange(deps[depName]);
+                if (workspace) {
+                    if (workspace.selector === 'explicit')
+                        deps[depName] = `workspace:^${to}`;
+                    continue;
+                }
+                deps[depName] = '^' + to;
+            }
+        }
+    },
+    /**
+     * What the npm registry says this package's current version is - used *only* by
+     * `detectChangeHash`, to guess a tag name for a package that has no git tag yet. See
+     * `ManifestProvider.publishedVersion` for why that is not a "has this been published" check.
+     *
+     * No `--registry`/`--userconfig`: a bare `npm view` run in the package's own directory already
+     * honours the repository's `.npmrc`, and the flags exist for `publish`'s CLI overrides, which
+     * this path has none of.
+     */
+    publishedVersion(pkg) {
+        return npmViewVersion(pkg.name, pkg.dirname);
+    },
+    /**
+     * npm's source shape: a quoted string assigned to an identifier, which is what a `.ts`/`.js`
+     * version constant looks like. `constant` comes from the repository's own `version.stamp` entry,
+     * for a file whose identifier is not literally `version`.
+     *
+     * One line, because `stampVersionConstant` is exported for it - the *pattern* is shared by most
+     * languages, while *choosing* it is this ecosystem's call. A provider for a format with no
+     * identifier at all (a `pom.xml`) would ignore `constant` and match its own way.
+     */
+    stampVersion(file, content, version, options) {
+        return stampVersionConstant(content, version, options?.constant);
+    },
+    write(dir, manifest) {
+        /**
+         * The version is written back into `raw` before serializing, because `raw` is the document and
+         * `manifest.version` is rman's view of one field in it. Writing only the view would produce a
+         * file whose `version` never changed; writing only `raw` would leave the two disagreeing for
+         * anything still holding the manifest.
+         */
+        const raw = { ...manifest.raw, version: manifest.version };
+        fs.writeFileSync(path.join(dir, 'package.json'), JSON.stringify(raw, undefined, 2) + '\n', 'utf-8');
+    },
+};
+/** npm's four dependency fields. Was `rman`'s `DEPENDENCY_KEYS`, which made the core carry npm's
+ *  field names - `publish` imports it from here now. */
+export const DEPENDENCY_KEYS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+/** Registers the provider with rman. Called by the plugin entry point, once. */
+export function augmentManifest() {
+    Manifest.addProvider(packageJsonManifest);
+}

package/augmentation/rman.augmentation.d.ts

@@ -0,0 +1,45 @@
+import type { NodeConfigKeys, RmanNodeConfig } from '../interfaces/rman-config.interface.js';
+import type { CiService } from '../services/ci.service.js';
+/**
+ * **Every type this plugin adds to rman, in one `declare module` block.**
+ *
+ * One block, and that is not tidiness: a *second* `declare module 'rman'` anywhere in this package
+ * silently disables the first. Measured - moving the config keys into their own file left
+ * `SystemInfo.PackageManager` unresolved at four call sites in `system-info.augmentation.ts`, with
+ * no error pointing at the cause. So a new augmentation goes **here**, beside the others, rather
+ * than next to the code it belongs to.
+ *
+ * Type-only. The runtime half of each augmentation lives with its own subject
+ * (`augmentSystemInfo()`, `augmentManifest()`, ...); this file is imported by the plugin's entry
+ * point purely so a consumer's compiler loads it.
+ */
+declare module 'rman' {
+    /**
+     * The `.rmanrc` keys that only mean something in a Node repository - merged into the core's own
+     * key list, so `pkg.config.clean` is typed wherever it is read (`CleanService` included) without
+     * a cast, and without the core declaring a key it knows nothing about.
+     *
+     * `WithAppend<RmanConfigKeys>` is a mapped type evaluated where it is used, so `+clean` comes
+     * along on its own.
+     */
+    interface RmanConfigKeys extends NodeConfigKeys {
+    }
+    namespace RmanConfig {
+        /** The npm half of `publish`. `target`, `skip` and `docker` stay in the core: the first two are
+         *  read by `list` and by every target's own plan, and Docker publishing is not Node's. */
+        interface PublishOptionsKeys extends RmanNodeConfig.PublishOptions {
+        }
+    }
+    namespace SystemInfo {
+        type PackageManager = CiService.PackageManager;
+        interface Options {
+            /**
+             * Report this package manager's version under `Binaries`, plus the `npmPackages` sections.
+             *
+             * Defaults to `.rmanrc "packageManager"` (read off `Options.repository`), then to `npm` -
+             * this package being installed is itself the statement that the repository is a Node one.
+             */
+            packageManager?: PackageManager;
+        }
+    }
+}

package/augmentation/rman.augmentation.js

@@ -0,0 +1 @@
+export {};

package/augmentation/run.augmentation.d.ts

@@ -0,0 +1,15 @@
+import { RunService } from 'rman';
+/**
+ * Teaches `run` about `package.json#scripts`.
+ *
+ * rman's core resolves a script from `.rmanrc` alone - `before`/`exec`/`after`. That a script might
+ * *also* live in `package.json`, that `prebuild` and `postbuild` run around `build`, and that
+ * `a && b` is two steps rather than one, are all facts about npm, so they are here.
+ *
+ * Registered as a `RunService` step source rather than by wrapping anything: the npm part of `run`
+ * is inside step resolution, not at its entry point, so there is nothing a wrapper could reach.
+ * The core decides what to do with what this returns - see `getScriptSteps` for the precedence.
+ */
+export declare const packageJsonSteps: RunService.StepSource;
+/** Registers the source with rman's `run`. Called by the plugin entry point, once. */
+export declare function augmentRun(): void;

package/augmentation/run.augmentation.js

@@ -0,0 +1,61 @@
+import parseNpmScript from '@netlify/parse-npm-script';
+import { RunService } from 'rman';
+/**
+ * Teaches `run` about `package.json#scripts`.
+ *
+ * rman's core resolves a script from `.rmanrc` alone - `before`/`exec`/`after`. That a script might
+ * *also* live in `package.json`, that `prebuild` and `postbuild` run around `build`, and that
+ * `a && b` is two steps rather than one, are all facts about npm, so they are here.
+ *
+ * Registered as a `RunService` step source rather than by wrapping anything: the npm part of `run`
+ * is inside step resolution, not at its entry point, so there is nothing a wrapper could reach.
+ * The core decides what to do with what this returns - see `getScriptSteps` for the precedence.
+ */
+export const packageJsonSteps = (pkg, script) => {
+    const scripts = pkg.manifest.raw?.scripts;
+    if (!scripts || typeof scripts !== 'object')
+        return undefined;
+    const declared = (name) => typeof scripts[name] === 'string' && !!scripts[name];
+    if (!declared(script) && !declared('pre' + script) && !declared('post' + script))
+        return undefined;
+    /**
+     * `parseNpmScript` expands npm's own lifecycle - `pre<script>`, the script, `post<script>` - and
+     * splits each on `&&` into the commands npm would run in sequence. The placeholder matters: it
+     * asks for a script the package may not declare itself (it may have only a `prebuild`), and
+     * without something there the parser reports the whole chain as absent.
+     */
+    const json = { ...pkg.manifest.raw, scripts: { ...scripts } };
+    json.scripts[script] = json.scripts[script] || PLACEHOLDER;
+    const info = parseNpmScript(json, 'npm run ' + script);
+    if (!info?.raw?.length)
+        return undefined;
+    const slots = { before: [], exec: [], after: [] };
+    for (const step of info.steps) {
+        const slot = slotOf(step.name, script);
+        if (!slot)
+            continue;
+        for (const command of Array.isArray(step.parsed) ? step.parsed : [step.parsed]) {
+            if (command === PLACEHOLDER)
+                continue;
+            slots[slot].push(command);
+        }
+    }
+    return slots;
+};
+/** Registers the source with rman's `run`. Called by the plugin entry point, once. */
+export function augmentRun() {
+    RunService.addStepSource(packageJsonSteps);
+}
+/** npm's lifecycle names, mapped onto rman's three slots. */
+function slotOf(stepName, script) {
+    if (stepName === 'pre' + script)
+        return 'before';
+    if (stepName === script)
+        return 'exec';
+    if (stepName === 'post' + script)
+        return 'after';
+    return undefined;
+}
+/** Stands in for a script the package does not declare. `#` is a shell comment, so were it ever to
+ *  reach a shell it would do nothing - but it is filtered out above instead. */
+const PLACEHOLDER = '#';

package/augmentation/system-info.augmentation.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Adds the npm half of `SystemInfo` to rman's own types.
+ *
+ * The core's `Options` carries nothing language-specific on purpose, so `packageManager` is not a
+ * setting it hid behind a flag - it is a setting it does not have. Declaration merging is what lets
+ * this package add it as if it had always been there, `SystemInfo.PackageManager` included, without
+ * the core naming npm anywhere.
+ *
+ * The union itself is `CiService.PackageManager`, not a second copy: `ci` and `publish` already
+ * shell out to one of these, and two lists of the same four names drift the moment a fifth appears.
+ */
+/** The import above is aliased precisely so this block can use the real name: declaration merging
+ *  keys off the module specifier, not off any local binding, so `namespace SystemInfo` here *is*
+ *  rman's - and nothing shadows anything. */
+/** The `SystemInfo` types this file's wrapper relies on are declared in
+ *  [`rman.augmentation.ts`](rman.augmentation.ts), with the rest of this plugin's - one
+ *  `declare module` block per package, or the others stop applying. */
+/**
+ * Turns the npm half on at runtime.
+ *
+ * Applied by wrapping rather than by a flag on the core service: "is this a Node repository" is not
+ * a question rman's core should be able to ask, and a `nodejs: true` option there would be exactly
+ * that question wearing a different hat. The wrapper translates `packageManager` into the `envinfo`
+ * categories the core knows nothing about.
+ */
+export declare function augmentSystemInfo(): void;

package/augmentation/system-info.augmentation.js

@@ -0,0 +1,79 @@
+import { SystemInfo as OrgSystemInfo } from 'rman';
+/**
+ * Adds the npm half of `SystemInfo` to rman's own types.
+ *
+ * The core's `Options` carries nothing language-specific on purpose, so `packageManager` is not a
+ * setting it hid behind a flag - it is a setting it does not have. Declaration merging is what lets
+ * this package add it as if it had always been there, `SystemInfo.PackageManager` included, without
+ * the core naming npm anywhere.
+ *
+ * The union itself is `CiService.PackageManager`, not a second copy: `ci` and `publish` already
+ * shell out to one of these, and two lists of the same four names drift the moment a fifth appears.
+ */
+/** The import above is aliased precisely so this block can use the real name: declaration merging
+ *  keys off the module specifier, not off any local binding, so `namespace SystemInfo` here *is*
+ *  rman's - and nothing shadows anything. */
+/** The `SystemInfo` types this file's wrapper relies on are declared in
+ *  [`rman.augmentation.ts`](rman.augmentation.ts), with the rest of this plugin's - one
+ *  `declare module` block per package, or the others stop applying. */
+/**
+ * Turns the npm half on at runtime.
+ *
+ * Applied by wrapping rather than by a flag on the core service: "is this a Node repository" is not
+ * a question rman's core should be able to ask, and a `nodejs: true` option there would be exactly
+ * that question wearing a different hat. The wrapper translates `packageManager` into the `envinfo`
+ * categories the core knows nothing about.
+ */
+export function augmentSystemInfo() {
+    const base = OrgSystemInfo.getSystemInfo;
+    /**
+     * Idempotent, and marked on **the function** rather than in a module-level flag: the flag made
+     * re-application impossible once anything had replaced `getSystemInfo` - a test substituting a
+     * stub, or a second augmentation layering on - so whether the wrapper was actually installed came
+     * down to import order. Asking the current implementation whether it is already wrapped cannot go
+     * stale that way.
+     */
+    if (base[AUGMENTED])
+        return;
+    /** A namespace's exported function is a property of a plain object at runtime, so this is an
+     *  ordinary assignment - the ESM *binding* is immutable, the object it points at is not. */
+    const wrapped = options => {
+        /** An explicit argument first, then the repository's own config, then npm. The config step is
+         *  why the core declares `Options.repository`: `rman info` passes only that, so without it a
+         *  pnpm repository would silently be reported as an npm one. */
+        const packageManager = options?.packageManager ?? asPackageManager(options?.repository?.config?.packageManager) ?? 'npm';
+        return base({
+            ...options,
+            envinfo: {
+                /** Replaces the core's `Binaries: ['Node']` - `envinfo` categories merge by key, not by
+                 *  concatenation, so the whole list has to be restated. */
+                Binaries: ['Node', PACKAGE_MANAGER_BINARY[packageManager]],
+                /** This package's own version alongside rman's - when `info` is being read to work out why
+                 *  a command behaved oddly, which plugin version is installed is half the answer. */
+                npmPackages: ['rman', 'rman-node', 'typescript'],
+                npmGlobalPackages: ['typescript'],
+                ...options?.envinfo,
+            },
+        });
+    };
+    wrapped[AUGMENTED] = true;
+    OrgSystemInfo.getSystemInfo = wrapped;
+}
+/** `.rmanrc "packageManager"` value -> the `Binaries` key `envinfo` recognizes for it (`npm`/
+ *  `pnpm`/`bun` are lowercase, `Yarn` isn't - envinfo's own naming, not ours). */
+const PACKAGE_MANAGER_BINARY = {
+    npm: 'npm',
+    yarn: 'Yarn',
+    pnpm: 'pnpm',
+    bun: 'bun',
+};
+/** A config value is whatever the file said, so an unrecognized one is ignored rather than used to
+ *  index `PACKAGE_MANAGER_BINARY` and produce `Binaries: ['Node', undefined]`. */
+function asPackageManager(value) {
+    return typeof value === 'string' && value in PACKAGE_MANAGER_BINARY
+        ? value
+        : undefined;
+}
+/** Marks an implementation as already wrapped. A symbol rather than a property name so it cannot
+ *  collide with anything `envinfo` or a future core option carries. */
+const AUGMENTED = Symbol.for('rman-node.systemInfo.augmented');

package/augmentation/workspace.augmentation.d.ts

@@ -0,0 +1,18 @@
+import { Workspace } from 'rman';
+/**
+ * Finds an npm workspace's packages: the `workspaces` globs in the root `package.json`, keeping
+ * every matched directory that holds a `package.json` of its own.
+ *
+ * This is the deepest thing that moved out of the core, and the one that most needed to. "A package
+ * is a directory with a `package.json`" and "the repository lists its members in `workspaces`" are
+ * npm's ideas - a Cargo workspace, a `go.work` and a `pyproject.toml` each say the same thing
+ * differently, and a core that hardcoded one of them could never read the others.
+ *
+ * Returns `undefined` for a root with no `workspaces` array, which is how a single-package
+ * repository still works: the core treats "no provider recognized this" as "the repository is the
+ * package". Note that this makes no upward walk of its own - the root was already decided, without
+ * any ecosystem's help, before this is called.
+ */
+export declare const npmWorkspace: Workspace.Provider;
+/** Registers the provider with rman. Called by the plugin entry point, once. */
+export declare function augmentWorkspace(): void;

package/augmentation/workspace.augmentation.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import glob from 'fast-glob';
+import { Workspace } from 'rman';
+/**
+ * Finds an npm workspace's packages: the `workspaces` globs in the root `package.json`, keeping
+ * every matched directory that holds a `package.json` of its own.
+ *
+ * This is the deepest thing that moved out of the core, and the one that most needed to. "A package
+ * is a directory with a `package.json`" and "the repository lists its members in `workspaces`" are
+ * npm's ideas - a Cargo workspace, a `go.work` and a `pyproject.toml` each say the same thing
+ * differently, and a core that hardcoded one of them could never read the others.
+ *
+ * Returns `undefined` for a root with no `workspaces` array, which is how a single-package
+ * repository still works: the core treats "no provider recognized this" as "the repository is the
+ * package". Note that this makes no upward walk of its own - the root was already decided, without
+ * any ecosystem's help, before this is called.
+ */
+export const npmWorkspace = (root) => {
+    const manifest = path.join(root, 'package.json');
+    if (!fs.existsSync(manifest))
+        return undefined;
+    let patterns;
+    try {
+        patterns = JSON.parse(fs.readFileSync(manifest, 'utf-8'))?.workspaces;
+    }
+    catch {
+        /** A malformed root `package.json` is not this provider's error to report - `Package` will do
+         *  it with the file in hand when something actually reads the manifest. */
+        return undefined;
+    }
+    if (!Array.isArray(patterns))
+        return undefined;
+    const packageDirs = [];
+    for (const pattern of patterns) {
+        if (typeof pattern !== 'string')
+            continue;
+        const dirs = glob.sync(pattern, { cwd: root, absolute: true, deep: 0, onlyDirectories: true });
+        for (const dir of dirs) {
+            if (fs.existsSync(path.join(dir, 'package.json')))
+                packageDirs.push(dir);
+        }
+    }
+    return { root, packageDirs };
+};
+/** Registers the provider with rman. Called by the plugin entry point, once. */
+export function augmentWorkspace() {
+    Workspace.addProvider(npmWorkspace);
+}

package/commands/ci.command.d.ts

@@ -0,0 +1,9 @@
+import { type CustomCommand } from 'rman';
+/**
+ * `rman ci` - contributed by the `rman-node` plugin rather than built into rman.
+ *
+ * A plugin's command is a `CustomCommand`, so the repository arrives through `context` instead of
+ * being captured when the command is registered - the same shape a repository's own `.rman/*.mjs`
+ * command has, and the reason both can be registered through one code path.
+ */
+export declare const command: CustomCommand;