rman 1.0.12 → 1.2.1

package/rmanrc.schema.json

@@ -1,392 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://raw.githubusercontent.com/panates/rman/main/schemas/rmanrc.schema.json",
-  "title": "rman configuration",
-  "description": "Schema for rman's .rmanrc (JSON) and .rmanrc.yml (YAML) config files, and the \"rman\" key in package.json. See docs/api.md#configuration-rmanrc-rmanrcyml for the full reference. Any string value may embed ${{ ... }} expressions - real JavaScript, evaluated per package against pkg, repository, env and semver - so one declaration at the root can still say something package-specific (\"../../coverage/${{ pkg.basename }}\", \"panates/${{ pkg.basename }}:${{ semver.major(pkg.version) }}\"). A string that is nothing but one expression keeps that value's own type. A bare {{ ... }} is left alone, so a command carrying someone else's template survives untouched.",
-  "type": "object",
-  "additionalProperties": false,
-  "patternProperties": {
-    "^\\[.+\\]$": {
-      "$ref": "#",
-      "description": "Config for the packages this selector names, rather than for the package of the directory declaring it - \"[*]\" for every package in the repository, \"[*-dialect]\" for a glob over package names, \"[pkg-a]\" for one. In YAML the quotes are REQUIRED: a bare [*] parses as a flow sequence and * as an alias indicator. Precedence, lowest first: \"[*]\", then other selectors in declaration order, then the package's own unmarked config."
-    }
-  },
-  "properties": {
-    "$schema": {
-      "type": "string",
-      "description": "Path/URL to this schema - not read by rman itself, purely for editor tooling."
-    },
-    "packageManager": {
-      "type": "string",
-      "enum": [
-        "npm",
-        "yarn",
-        "pnpm",
-        "bun"
-      ],
-      "default": "npm",
-      "description": "Package manager used by \"ci\"/\"publish\". Root-level only - an explicit --package-manager CLI flag wins over this."
-    },
-    "logLevel": {
-      "$ref": "#/definitions/logLevel",
-      "default": "info",
-      "description": "Default verbosity of the classic per-step log for run/build/test/ci/clean. Root-level only. An explicit --log-level CLI flag wins over this."
-    },
-    "allowBranch": {
-      "$ref": "#/definitions/stringOrStringArray",
-      "description": "Refuse to run a state-changing command unless the current git branch matches one of these globs. Root-level only. An explicit --allow-branch CLI flag replaces this entirely (never merges)."
-    },
-    "ignoreBranch": {
-      "$ref": "#/definitions/stringOrStringArray",
-      "description": "Refuse to run a state-changing command if the current git branch matches one of these globs. Root-level only. An explicit --ignore-branch CLI flag replaces this entirely (never merges)."
-    },
-    "group": {
-      "description": "Release-versioning group for \"version\"/\"publish\": true (default) puts the package in the implicit repo-wide group; a string joins exactly the other packages sharing that string; false makes it a solo, fully independent group. Per-package cascaded.",
-      "default": true,
-      "oneOf": [
-        {
-          "type": "boolean"
-        },
-        {
-          "type": "string",
-          "minLength": 1
-        }
-      ]
-    },
-    "version": {
-      "type": "object",
-      "description": "Options for the \"version\" command/VersionService.",
-      "additionalProperties": false,
-      "properties": {
-        "commitMessage": {
-          "type": "string",
-          "default": "chore(release): v{version}",
-          "description": "Commit message for every group a \"version\" run commits. \"{version}\" is substituted when every bumped package in that commit shares one version. Root-level only."
-        },
-        "changelog": {
-          "type": "boolean",
-          "default": false,
-          "description": "Default for \"version --changelog\" when the CLI flag isn't given - an explicit --changelog/--no-changelog still wins. Root-level only."
-        },
-        "releaseTagPattern": {
-          "type": "string",
-          "default": "release-*",
-          "description": "Root-level. Tag naming the repository's own release, as opposed to the per-package/group tags \"changelog.tagPattern\" names - only created when the root is on a calendar version (a repo with more than one version line). Must NOT match any package's \"changelog.tagPattern\", or that package's changelog boundary resolves to the repository release instead of its own."
-        },
-        "stampDockerfile": {
-          "type": "boolean",
-          "default": true,
-          "description": "Per-package cascaded. Keep this package's Dockerfile \"org.opencontainers.image.version\" label in step with the version being written, in the same commit as the bump. The label's value is by specification the version of the packaged software, so there is only one correct value for it. Only ever rewrites a label the Dockerfile already declares (never inserts one), and reads the same path \"publish --target docker\" builds from (\"publish.docker.dockerfile\")."
-        },
-        "stamp": {
-          "$ref": "#/definitions/stringOrStringArray",
-          "description": "Source files whose \"version\" constant is rewritten to the version being written, in the same commit as the bump - paths relative to the package's own directory (e.g. [\"src/constants.ts\"]). Per-package cascaded; a listed file a package doesn't have is a silent no-op. Stamps the source rather than the build output, so anything running from source reports the real version and git records it."
-        },
-        "before": {
-          "$ref": "#/definitions/stringOrStringArray",
-          "description": "Command(s) to run as this package's own \"preversion\" step, when its package.json does not define one itself."
-        },
-        "exec": {
-          "$ref": "#/definitions/stringOrStringArray",
-          "description": "Command(s) to run as this package's own \"version\" npm-lifecycle step, when its package.json does not define one itself."
-        },
-        "after": {
-          "$ref": "#/definitions/stringOrStringArray",
-          "description": "Command(s) to run as this package's own \"postversion\" step, when its package.json does not define one itself."
-        }
-      }
-    },
-    "changelog": {
-      "type": "object",
-      "description": "Options for the \"changelog\" command/ChangelogService, and for \"version --changelog\".",
-      "additionalProperties": false,
-      "properties": {
-        "ignoreTypes": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "default": [],
-          "description": "Conventional Commit types (e.g. \"chore\", \"ci\") dropped entirely from changelog output, instead of being folded into \"Other Changes\". Per-package cascaded."
-        },
-        "template": {
-          "type": "string",
-          "description": "Path (relative to the repository root) to a changelog template file - not the template text itself. Supports {{package}}/{{version}}/{{date}}/{{commits}} and {{features}}/{{fixes}}/{{other}}. Per-package cascaded."
-        },
-        "filePath": {
-          "type": "string",
-          "default": "CHANGELOG.md",
-          "description": "Where \"--write\" prepends this package's entry, relative to that package's own directory. Per-package cascaded."
-        },
-        "tagPattern": {
-          "type": "string",
-          "default": "v*",
-          "description": "Glob for this package's release tags. Include \"{name}\" for independent per-package tags (e.g. \"{name}@*\"); omit it for one shared repo-wide tag scheme. Per-package cascaded."
-        }
-      }
-    },
-    "clean": {
-      "type": "object",
-      "description": "Options for the \"clean\" command/CleanService.",
-      "additionalProperties": false,
-      "properties": {
-        "include": {
-          "$ref": "#/definitions/stringOrStringArray",
-          "description": "Extra glob(s) to remove, resolved relative to this package's own directory. Per-package cascaded (a package's own value replaces the root's, it does not merge)."
-        },
-        "exclude": {
-          "$ref": "#/definitions/stringOrStringArray",
-          "description": "Glob(s) protected from \"include\" (and from the built-in TypeScript-artifact cleanup), relative to this package's own directory. Per-package cascaded."
-        },
-        "skip": {
-          "type": "boolean",
-          "default": false,
-          "description": "Opts this package out of \"clean\" entirely. Per-package cascaded."
-        }
-      }
-    },
-    "publish": {
-      "type": "object",
-      "description": "Options for the \"publish\" command/PublishService and DockerPublishService. Per-package cascaded.",
-      "additionalProperties": false,
-      "properties": {
-        "target": {
-          "description": "Which registry \"publish\" ships this package to. Default [\"npm\"]. A package that only ships Docker images (typically also \"private\": true) sets [\"docker\"]; both works too. Each target answers \"is this version already out there?\" against its own registry: npm via \"npm view\", docker via \"docker manifest inspect\". This is strictly about package distribution - the repository's GitHub Release is not a target here, see \"githubRelease\" and the \"github-release\" command.",
-          "default": [
-            "npm"
-          ],
-          "oneOf": [
-            {
-              "$ref": "#/definitions/publishTarget"
-            },
-            {
-              "type": "array",
-              "items": {
-                "$ref": "#/definitions/publishTarget"
-              }
-            }
-          ]
-        },
-        "directory": {
-          "type": "string",
-          "description": "Where this package's publishable output lives, relative to its own directory (e.g. \"build\"). Per-package cascaded, so a root \"[*]\" block can say it once instead of repeating publishConfig.directory in every package.json - which still wins when a package declares it. Publishing from such a directory means the manifest there is GENERATED by publish, from the package's own, with devDependencies, non-install scripts, \"private\" and publishConfig.directory removed and \"workspace:\" ranges resolved. There is nothing to configure about it."
-        },
-        "docker": {
-          "$ref": "#/definitions/dockerPublishConfig",
-          "description": "Required once \"docker\" is one of this package's \"publish.target\"s."
-        },
-        "skip": {
-          "type": "boolean",
-          "default": false,
-          "description": "Excludes this package from \"publish\" entirely (every target), regardless of \"target\"/\"private\" - a single, explicit \"never published\" statement. \"changelog\" also skips it by default (see its own --include-skipped). Independent of \"version\", which never consults this."
-        }
-      }
-    },
-    "githubRelease": {
-      "$ref": "#/definitions/githubReleaseConfig",
-      "description": "Details of the repository's GitHub Release (\"github-release\"/GithubReleaseService). Entirely optional - every required fact already has a sensible default source. Nothing here decides whether a release is cut: a release records that the repository shipped, so it is always cut. \"assets\" is per-package cascaded; the rest is root-level only."
-    },
-    "run": {
-      "type": "object",
-      "description": "Per-script options for \"run\"/\"build\"/\"test\"/RunService, keyed by npm script name (e.g. \"build\", \"lint\", \"test\"). A bare string (or array of them) is shorthand for { \"exec\": ... } - \"test\": \"mocha\" and \"test\": { \"exec\": \"mocha\" } mean exactly the same thing.",
-      "additionalProperties": {
-        "oneOf": [
-          {
-            "$ref": "#/definitions/stringOrStringArray"
-          },
-          {
-            "$ref": "#/definitions/runScriptConfig"
-          }
-        ]
-      }
-    },
-    "dependencies": {
-      "description": "In-repo packages this one depends on beyond what its real package.json declares, purely for rman's own dependency graph (topo-sort, --deps/--dependents, run's task scheduling). An array defaults each entry's range to \"*\"; an object gives an explicit name -> range map. Declare it from the root through a selector (\"[pkg-a]\": { \"dependencies\": [...] }) or in the package's own .rmanrc.",
-      "oneOf": [
-        {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        },
-        {
-          "type": "object",
-          "additionalProperties": {
-            "type": "string"
-          }
-        }
-      ]
-    }
-  },
-  "definitions": {
-    "logLevel": {
-      "type": "string",
-      "enum": [
-        "silent",
-        "error",
-        "info",
-        "verbose"
-      ]
-    },
-    "stringOrStringArray": {
-      "oneOf": [
-        {
-          "type": "string",
-          "minLength": 1
-        },
-        {
-          "type": "array",
-          "items": {
-            "type": "string",
-            "minLength": 1
-          }
-        }
-      ]
-    },
-    "publishTarget": {
-      "type": "string",
-      "enum": [
-        "npm",
-        "docker"
-      ]
-    },
-    "dockerPublishConfig": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "image"
-      ],
-      "properties": {
-        "image": {
-          "type": "string",
-          "minLength": 1,
-          "description": "DockerHub image name/repository - bare (e.g. \"my-app\") to be prefixed with --docker-namespace/DOCKERHUB_NAMESPACE, or already-namespaced (contains a \"/\") to use verbatim."
-        },
-        "dockerfile": {
-          "type": "string",
-          "default": "Dockerfile",
-          "description": "Relative to the package's own directory."
-        },
-        "platforms": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "default": [
-            "linux/amd64"
-          ],
-          "description": "\"docker buildx build --platform\" targets."
-        },
-        "cwd": {
-          "type": "string",
-          "description": "Build cwd override, relative to the repository root - only needed when the Dockerfile's own COPY/ADD paths expect something other than the package's own directory."
-        },
-        "buildContexts": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "string"
-          },
-          "description": "Named \"docker buildx build --build-context <name>=<path>\" entries, keyed by name - each path relative to the package's own directory (or absolute)."
-        },
-        "buildArgs": {
-          "type": "object",
-          "additionalProperties": {
-            "type": "string"
-          },
-          "description": "\"docker buildx build --build-arg <name>=<value>\" entries - a value of exactly \"$NAME\" expands to the NAME environment variable at build time."
-        },
-        "readme": {
-          "type": "string",
-          "default": "DOCKER_README.md",
-          "description": "A file (relative to the package's own directory) whose contents become the DockerHub repo's full description, if present."
-        }
-      }
-    },
-    "githubReleaseConfig": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "assets": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "description": "Files to attach to the release, as glob patterns relative to the package's own directory (e.g. [\"dist/*.tar.gz\"]). Read from every package, since one release covers the whole source tree. A release with no assets is still valid."
-        },
-        "repository": {
-          "type": "string",
-          "description": "\"owner/repo\". Default: parsed from the \"origin\" remote's URL."
-        },
-        "draft": {
-          "type": "boolean",
-          "default": false,
-          "description": "Create the release as an unpublished draft."
-        },
-        "prerelease": {
-          "type": "boolean",
-          "description": "Default: whether the version being released is itself a semver prerelease."
-        }
-      }
-    },
-    "runScriptConfig": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "concurrency": {
-          "type": "integer",
-          "minimum": 1,
-          "description": "Max packages built at once for this script. Default: CPU count."
-        },
-        "topo": {
-          "type": "boolean",
-          "default": true,
-          "description": "Respect the package dependency graph: a package waits for its dependencies and is skipped if one fails. Set false for independent scripts (lint/test) - alphabetical order, no failure skipping."
-        },
-        "bail": {
-          "type": "boolean",
-          "default": true,
-          "description": "Stop the whole batch on this package's own failure. Unusual precedence: this package-level value outranks even an explicit CLI --bail/--no-bail flag."
-        },
-        "progress": {
-          "type": "boolean",
-          "default": true,
-          "description": "Show the live progress panel for this script (auto-disabled off a TTY)."
-        },
-        "logLevel": {
-          "$ref": "#/definitions/logLevel",
-          "description": "Verbosity of the classic per-step log for this package/script, when the live panel is off."
-        },
-        "changedSince": {
-          "type": "string",
-          "description": "Root-level fallback commit/hash for \"--changed-since\", used only when the CLI flag is not given."
-        },
-        "skip": {
-          "type": "boolean",
-          "default": false,
-          "description": "Excludes this package (or the repository root's own pre/post hooks) from running this script entirely."
-        },
-        "if": {
-          "type": "string",
-          "description": "Conditional-execution expression: atoms \"changed\"/\"dirty\"/\"committed\" (optionally \"= <hash>\" or \"= {ENV_VAR}\"), combined with and/or/not/(...). E.g. \"changed\", \"(changed or dirty) and not committed\"."
-        },
-        "before": {
-          "$ref": "#/definitions/stringOrStringArray",
-          "description": "Command(s) to run as this package's own \"pre<script>\" hook, when its package.json does not define one."
-        },
-        "exec": {
-          "$ref": "#/definitions/stringOrStringArray",
-          "description": "Command(s) to run as this package's own script, when its package.json does not define one for this script name."
-        },
-        "after": {
-          "$ref": "#/definitions/stringOrStringArray",
-          "description": "Command(s) to run as this package's own \"post<script>\" hook, when its package.json does not define one."
-        },
-        "override": {
-          "type": "boolean",
-          "default": false,
-          "description": "When true, \"before\"/\"exec\"/\"after\" above replace the package's own package.json definition even when it already has one."
-        }
-      }
-    }
-  }
-}

package/services/ci.service.d.ts

@@ -1,40 +0,0 @@
-import type { Repository } from '../core/repository.js';
-import { type LogLevel } from '../utils/logger.js';
-import { type PackageFilterOptions } from '../utils/package-filter.js';
-export declare namespace CiService {
-    type PackageManager = (typeof PACKAGE_MANAGERS)[number];
-    interface Options extends PackageFilterOptions {
-        packageManager?: PackageManager;
-        /** Show the live progress panel while running. Default true, same as `run`/`build`; auto-disabled
-         *  when stdout isn't a TTY. Doesn't affect what's printed once done - see `run`. */
-        progress?: boolean;
-        /** Verbosity of the classic per-step log (only applies when the live panel is off). Falls back to
-         *  the root's `.rmanrc logLevel`, then 'info' - see `resolveRootLogLevel`. */
-        logLevel?: LogLevel;
-    }
-    /** `.rmanrc packageManager` (root only) picks the package manager used for the final install;
-     *  explicit CLI value wins over it. Defaults to 'npm'. */
-    function resolvePackageManager(repository: Repository, cliValue?: PackageManager): PackageManager;
-    /** Deletes `node_modules` and any known lockfile directly under `dirname`. Returns the names
-     *  that actually existed (and were removed), so the caller can log only those. */
-    function wipe(dirname: string): Promise<string[]>;
-    /**
-     * `ci`: a from-scratch, reproducible install for CI pipelines. For every package (root
-     * included), deletes `node_modules` and any lockfile - or, if the package defines its own
-     * `"ci"` script, runs that instead. Once every package is clean, installs once at the root
-     * with the configured package manager (`npm`/`yarn`/`pnpm`/`bun`).
-     *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) while it
-     * runs, falling back to a plain rmdir/clean/run/install log line per step when the panel is off.
-     *
-     * Unlike `run`/`build`, it does *not* end with a per-package success tally: `ci`'s packages don't
-     * have independently meaningful outcomes the way a build or test run does - wiping a package is
-     * trivial and the one step that can genuinely fail, the install, is a single operation for the
-     * whole repository. Counting "N succeeded" across packages would just be noise, so only actual
-     * failures get called out (by name, with whatever output they produced), followed by one plain
-     * completed/failed line.
-     */
-    function reinstall(repository: Repository, options?: Options): Promise<void>;
-}
-declare const PACKAGE_MANAGERS: readonly ["npm", "yarn", "pnpm", "bun"];
-export {};

package/services/ci.service.js

@@ -1,204 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import colors from 'ansi-colors';
-import { exec } from '../utils/exec.js';
-import { Logger, resolveRootLogLevel } from '../utils/logger.js';
-import { filterPackages } from '../utils/package-filter.js';
-import { formatDuration, ProgressPanel } from '../utils/progress-panel.js';
-export var CiService;
-(function (CiService) {
-    /** `.rmanrc packageManager` (root only) picks the package manager used for the final install;
-     *  explicit CLI value wins over it. Defaults to 'npm'. */
-    function resolvePackageManager(repository, cliValue) {
-        if (cliValue)
-            return cliValue;
-        const configured = repository.config?.packageManager;
-        if (configured === undefined)
-            return 'npm';
-        if (PACKAGE_MANAGERS.includes(configured))
-            return configured;
-        throw new Error(`Invalid "packageManager" in .rmanrc: "${configured}" (expected one of: ${PACKAGE_MANAGERS.join(', ')})`);
-    }
-    CiService.resolvePackageManager = resolvePackageManager;
-    /** Deletes `node_modules` and any known lockfile directly under `dirname`. Returns the names
-     *  that actually existed (and were removed), so the caller can log only those. */
-    async function wipe(dirname) {
-        const removed = [];
-        for (const name of ['node_modules', ...LOCK_FILES]) {
-            const target = path.join(dirname, name);
-            const existed = await fs
-                .access(target)
-                .then(() => true)
-                .catch(() => false);
-            if (!existed)
-                continue;
-            await fs.rm(target, { recursive: true, force: true });
-            removed.push(name);
-        }
-        return removed;
-    }
-    CiService.wipe = wipe;
-    /**
-     * `ci`: a from-scratch, reproducible install for CI pipelines. For every package (root
-     * included), deletes `node_modules` and any lockfile - or, if the package defines its own
-     * `"ci"` script, runs that instead. Once every package is clean, installs once at the root
-     * with the configured package manager (`npm`/`yarn`/`pnpm`/`bun`).
-     *
-     * Uses the same live progress panel as `run`/`build` (see `../utils/progress-panel.ts`) while it
-     * runs, falling back to a plain rmdir/clean/run/install log line per step when the panel is off.
-     *
-     * Unlike `run`/`build`, it does *not* end with a per-package success tally: `ci`'s packages don't
-     * have independently meaningful outcomes the way a build or test run does - wiping a package is
-     * trivial and the one step that can genuinely fail, the install, is a single operation for the
-     * whole repository. Counting "N succeeded" across packages would just be noise, so only actual
-     * failures get called out (by name, with whatever output they produced), followed by one plain
-     * completed/failed line.
-     */
-    async function reinstall(repository, options = {}) {
-        const packageManager = resolvePackageManager(repository, options.packageManager);
-        const logger = new Logger(options.logLevel ?? resolveRootLogLevel(repository));
-        // root is handled separately below - for a non-monorepo, getPackages() would otherwise
-        // include it a second time (it doubles as "the" package).
-        const packages = filterPackages(repository.getPackages().filter(p => p !== repository.rootPackage), options);
-        const progress = options.progress ?? true;
-        const panel = new ProgressPanel('CI', !!process.stdout.isTTY && progress);
-        const runStartedAt = Date.now();
-        panel.start();
-        const items = [];
-        let failed = false;
-        try {
-            const results = await Promise.allSettled(packages.map(pkg => {
-                const item = panel.addItem(pkg.name);
-                items.push(item);
-                return ciForPackage(pkg, item, panel.enabled, logger);
-            }));
-            if (results.some(r => r.status === 'rejected'))
-                failed = true;
-            const rootItem = panel.addItem('root');
-            items.push(rootItem);
-            try {
-                await ciForRoot(repository, rootItem, panel.enabled, packageManager, logger);
-            }
-            catch {
-                failed = true;
-            }
-        }
-        finally {
-            panel.stop();
-        }
-        for (const item of items) {
-            if (item.status !== 'failed')
-                continue;
-            logger.error(colors.red.bold('X'), item.name);
-            if (item.log.length)
-                logger.error(colors.red(item.log.join('\n')));
-        }
-        const totalElapsed = formatDuration(Date.now() - runStartedAt);
-        const summary = [failed ? colors.red('ci failed') : colors.green('ci completed'), colors.gray(`(${totalElapsed})`)];
-        if (failed)
-            logger.error(...summary);
-        else
-            logger.info(...summary);
-        if (failed) {
-            const err = new Error('"ci" failed');
-            err.logged = true;
-            throw err;
-        }
-    }
-    CiService.reinstall = reinstall;
-})(CiService || (CiService = {}));
-const PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm', 'bun'];
-const LOCK_FILES = ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lock', 'bun.lockb'];
-/** Runs a shell `command` in `cwd`, driving `item` for the live panel when it's on, or falling
- *  back to the plain "classic" log line `logLine` prints first - the same split `run`'s classic
- *  log uses. `logLine` is expected to go through a `Logger` (so it respects `--log-level`), not a
- *  raw `console.log`. */
-async function runStep(item, panelEnabled, cwd, command, logLine) {
-    if (panelEnabled) {
-        await exec(command, {
-            cwd,
-            stdio: 'pipe',
-            onLine: line => {
-                item.log.push(line);
-                item.lastLine = line;
-            },
-        });
-    }
-    else {
-        logLine();
-        await exec(command, { cwd, stdio: 'inherit' });
-    }
-}
-/** Logs (or reflects onto the live panel) the outcome of a `wipe()` call - including the "nothing
- *  to remove" case, which otherwise prints nothing at all in the classic log and can look like the
- *  package was never processed (most workspace layouts hoist deps to the root's `node_modules`,
- *  so an individual package legitimately has nothing of its own to wipe most of the time). */
-function logWipeResult(item, panelEnabled, logger, label, removed) {
-    if (panelEnabled) {
-        item.lastLine = removed.length ? `removed ${removed.join(', ')}` : 'already clean';
-        return;
-    }
-    if (!removed.length) {
-        logger.info(colors.gray('clean'), colors.cyan(label));
-        return;
-    }
-    for (const name of removed)
-        logger.info(colors.yellow('rmdir'), colors.cyan(label), name);
-}
-/** A package can opt out of the default wipe by defining its own `"ci"` npm script - if present,
- *  that runs instead of the wipe, same as any other rman script. */
-async function ciForPackage(pkg, item, panelEnabled, logger) {
-    item.status = 'running';
-    item.startedAt = Date.now();
-    try {
-        const script = pkg.json.scripts?.ci;
-        if (typeof script === 'string' && script) {
-            item.currentStep = 'ci';
-            await runStep(item, panelEnabled, pkg.dirname, script, () => logger.info(colors.cyan('run'), colors.cyan(item.name), script));
-        }
-        else {
-            item.currentStep = 'wipe';
-            const removed = await CiService.wipe(pkg.dirname);
-            logWipeResult(item, panelEnabled, logger, item.name, removed);
-        }
-        item.status = 'success';
-    }
-    catch (e) {
-        item.status = 'failed';
-        throw e;
-    }
-    finally {
-        item.finishedAt = Date.now();
-    }
-}
-/** The root gets one extra step over a regular package once it isn't opting out with its own
- *  `"ci"` script: after its own wipe, it installs once for the whole repository. */
-async function ciForRoot(repository, item, panelEnabled, packageManager, logger) {
-    item.status = 'running';
-    item.startedAt = Date.now();
-    try {
-        const script = repository.rootPackage.json.scripts?.ci;
-        if (typeof script === 'string' && script) {
-            item.currentStep = 'ci';
-            await runStep(item, panelEnabled, repository.dirname, script, () => logger.info(colors.cyan('run'), colors.cyan('root'), script));
-        }
-        else {
-            item.stepsTotal = 2;
-            item.stepIndex = 0;
-            item.currentStep = 'wipe';
-            const removed = await CiService.wipe(repository.dirname);
-            logWipeResult(item, panelEnabled, logger, 'root', removed);
-            item.stepIndex = 1;
-            item.currentStep = 'install';
-            await runStep(item, panelEnabled, repository.dirname, `${packageManager} install`, () => logger.info(colors.cyan('install'), `Running "${packageManager} install"`));
-        }
-        item.status = 'success';
-    }
-    catch (e) {
-        item.status = 'failed';
-        throw e;
-    }
-    finally {
-        item.finishedAt = Date.now();
-    }
-}