rman 0.37.4 → 1.0.1

package/README.md

@@ -1,33 +1,376 @@
-## rman
-  
+# rman
+
 [![NPM Version][npm-image]][npm-url]
 [![NPM Downloads][downloads-image]][downloads-url]
-[![Build Status][travis-image]][travis-url]
-[![Test Coverage][coveralls-image]][coveralls-url]
+[![Quality Check][qc-image]][qc-url]
+[![License][license-image]][license-url]
+
+**rman** is a monorepo management CLI: a self-contained alternative to reaching for Lerna,
+Changesets, and a handful of shell scripts glued together. One tool for running scripts across
+packages, computing semantic version bumps from your commit history, publishing, changelogs,
+importing external repos with history intact, and more - all driven by a single, cascading
+`.rmanrc`/`.rman.yml` config.
+
+Every command is also available as a **programmatic API** - see [docs/api.md](docs/api.md) if you
+want to call `rman`'s logic directly from a Node.js script instead of shelling out to the CLI.
+
+## Table of contents
+
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Commands](#commands)
+- [Configuration](#configuration)
+- [Programmatic API](#programmatic-api)
+- [Node compatibility](#node-compatibility)
+- [License](#license)
+
+## Installation
+
+```bash
+npm install --save-dev rman
+```
+
+Or run it without installing, via `npx`:
+
+```bash
+npx rman list
+```
+
+`rman` requires **Node.js >= 20**.
+
+## Quick start
+
+`rman` auto-detects your repository layout - point it at a directory containing a `package.json`
+with a `workspaces` array (npm/yarn/pnpm-style) and every matched package becomes available to
+every command:
+
+```json
+// package.json (repository root)
+{
+  "name": "my-monorepo",
+  "private": true,
+  "workspaces": ["packages/*"]
+}
+```
+
+```bash
+# See what's in the repository
+rman list
+
+# Run "build" in every package, dependencies first
+rman build
+
+# See what the next release would look like, without changing anything
+rman version
+
+# Apply it: bump versions, write CHANGELOG.md, commit, tag
+rman version --changelog
+
+# Publish everything that isn't already on the registry
+rman publish
+```
+
+Run any command with `--help` for its full option list (`rman version --help`, `rman run --help`, ...).
+
+## Commands
+
+The summaries and examples below cover the common cases. For the full option list, defaults, and
+worked examples of every single command, see **[docs/cli.md](docs/cli.md)**.
+
+| Command | Purpose |
+| --- | --- |
+| [`list` (`ls`)](#rman-list) | Lists packages in the repository. |
+| [`info`](#rman-info) | Prints local environment and repository information. |
+| [`run <script>`](#rman-run-script) | Runs an npm script in each package. |
+| [`build`](#rman-build) | Alias for `run build`. |
+| [`test`](#rman-test) | Alias for `run test`. |
+| [`exec <command..>`](#rman-exec-command) | Runs an arbitrary shell command in each package. |
+| [`ci`](#rman-ci) | Deletes `node_modules`/lockfiles everywhere, then reinstalls from scratch. |
+| [`clean`](#rman-clean) | Removes compiled TypeScript output and configured extra files/dirs. |
+| [`changed`](#rman-changed) | Shows which packages the next `version` run would bump. |
+| [`diff [package]`](#rman-diff-package) | Shows the git diff since a package's (or the repo's) last release tag. |
+| [`changelog`](#rman-changelog) | Generates a changelog per package from unreleased commits. |
+| [`version [bump]`](#rman-version-bump) | Bumps versions of changed packages (and their dependents). |
+| [`publish`](#rman-publish) | Publishes every non-private package not already on the registry. |
+| [`import <path>`](#rman-import-path) | Imports an external git repository as a new package, with history. |
+
+Options shared across several commands:
+
+- **Package filtering** (`list`, `run`/`build`/`test`, `exec`, `ci`, `clean`, `version`, `publish`,
+  `changelog`): `--scope <glob>`, `--ignore <glob>`, `--deps`, `--dependents` - see
+  [Package filtering](docs/api.md#package-filtering-scopeignoredepsdependents) for the full
+  semantics.
+- **Branch guard** (every command that mutates state or runs scripts - `run`/`build`/`test`,
+  `exec`, `ci`, `clean`, `version`, `publish`): `--allow-branch <glob>`, `--ignore-branch <glob>` -
+  refuses to run unless (or if) the current git branch matches, the same idea as GitHub Actions'
+  own `branches`/`branches-ignore` workflow filters.
+
+### `rman list`
+
+Lists packages in the repository (alias: `ls`).
+
+```bash
+rman list                       # table: Package / Version / Private / Changed / Path
+rman ls --short                 # just the bare package names
+rman list --json                # full detail as JSON
+rman list --parseable           # location::name::version::PRIVATE::STATUS lines, for scripting
+rman list --toposort            # dependencies before dependents, instead of directory order
+rman list --graph               # dependency graph as a JSON adjacency list
+rman list --changed             # only packages changed since the last publish
+rman list --changed-since HEAD~5
+rman list --scope '@myorg/*' --ignore '*-internal'
+```
+
+### `rman info`
+
+Prints local environment (OS/CPU/memory, Node/npm/Yarn versions, git) and repository information.
+
+```bash
+rman info
+rman info --json
+```
+
+### `rman run <script>`
+
+Runs an npm script in each package, in dependency order by default.
+
+```bash
+rman run build
+rman run lint --topo=false          # independent packages, alphabetical order, no dependency waiting
+rman run test --changed             # only in packages changed since the last publish
+rman run build --changed-since v1.2.0
+rman run build --parallel 4         # at most 4 packages at once
+rman run build --parallel false     # serially, one at a time
+rman run build --bail=false         # don't stop the whole batch on one package's failure
+rman run build --scope pkg-a --deps # pkg-a plus everything it depends on
+```
+
+Per-package/script behavior (pre/post hooks, `if` conditions, skip, concurrency, ...) is
+configurable via `.rmanrc run.<script>.*` - see [Configuration](#configuration) below and the full
+writeup in [docs/api.md](docs/api.md#runservice).
+
+### `rman build`
+
+Alias for `rman run build`.
+
+```bash
+rman build
+```
+
+### `rman test`
+
+Alias for `rman run test`.
+
+```bash
+rman test
+```
+
+### `rman exec <command..>`
+
+Runs an arbitrary shell command in each package - unlike `run`, it isn't tied to any npm script.
+
+```bash
+rman exec rm -rf dist
+rman exec -- eslint --fix          # "--" needed only if the command shares a flag name with exec's own
+rman exec --scope pkg-a -- ls -la
+rman exec --topo=false pwd         # every package independently, alphabetical order
+```
+
+### `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
+```
+
+### `rman changed`
+
+Shows which packages the next `rman version` run would bump, without changing anything.
+
+```bash
+rman changed
+rman changed --json
+```
+
+### `rman diff [package]`
+
+Shows the git diff since a package's (or the whole repository's) last release tag.
+
+```bash
+rman diff                # since the repository's own last tag
+rman diff pkg-a          # since pkg-a's own last tag, scoped to its directory
+```
+
+### `rman changelog`
+
+Generates a changelog per package from unreleased commits, grouped into ✨ Features / 🐛 Bug Fixes
+/ 🔧 Other Changes.
+
+```bash
+rman changelog                          # auto-detects each package's last published npm version
+rman changelog --from a1b2c3d           # since a specific commit, for every package
+rman changelog --write                  # prepend into each package's own CHANGELOG.md
+rman changelog --write --file-path docs/CHANGELOG.md
+```
+
+### `rman version [bump]`
+
+Bumps versions of changed packages (and their in-group dependents), grouped via `.rmanrc "group"`.
+
+```bash
+rman version                     # auto-detect severity from commits, preview only - writes nothing
+rman version --interactive       # preview, then ask for confirmation either way
+rman version patch               # apply a patch bump to every changed package/group, immediately
+rman version minor
+rman version major
+rman version 2.0.0-rc.1          # an explicit semver version, applied verbatim
+rman version minor --preid beta  # 1.2.3 -> 1.3.0-beta.0 (run again with --preid beta to increment it)
+rman version --changelog         # also write/fold in each bumped package's CHANGELOG.md
+rman version patch --push        # commit, tag, and push in one go
+rman version patch --message "chore(release): {version}"
+rman version --ignore-dirty      # exclude dirty packages instead of aborting the whole run
+```
+
+Severity, when not given explicitly, is auto-detected per package/group from
+[Conventional Commits](https://www.conventionalcommits.org/) since that group's last release tag -
+`fix:` → patch, `feat:` → minor, `feat!:`/a `BREAKING CHANGE:` footer → major. A `Release-As:
+patch|minor|major` commit-body footer can override one specific commit's own contribution to that
+- e.g. to ship a `feat:` as a patch right now instead of waiting for the rest of a minor's worth of
+work:
+
+```
+feat: needs to ship right now
+
+Release-As: patch
+```
+
+See [docs/api.md#versionservice](docs/api.md#versionservice) for the full grouping/propagation
+algorithm, prerelease semantics, and `"workspace:"` dependency-range handling.
+
+### `rman publish`
+
+Publishes every non-private package whose local version isn't already on the registry.
+
+```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
+```
+
+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/api.md#publishservice](docs/api.md#publishservice).
+
+### `rman import <path>`
+
+Imports an external git repository as a new package, preserving its **entire commit history**
+(`git blame`/`git log --follow` keep working on the imported files afterward).
+
+```bash
+rman import ../my-old-standalone-repo
+rman import ../my-old-standalone-repo --dest libs   # under libs/ instead of packages/
+```
+
+`path` must be a local clone (not a URL) - clone the source repository first if it isn't local
+already. After importing, add the new directory to your `workspaces` glob if it isn't already
+covered, then run `rman ci` to install it.
+
+## Configuration
+
+`rman` reads config cascaded from the repository root down to each package's own directory (the
+same way a `tsconfig.json` `extends` chain works) - a value set closer to a package overrides the
+same key set further up. Three file forms are supported per directory, merged in increasing
+precedence: `package.json`'s own `"rman"` key, `.rman.yml` (YAML), and `.rmanrc` (**JSON**, despite
+the dotfile-style name).
+
+```yaml
+# .rman.yml, at the repository root
+packageManager: pnpm
+logLevel: info
+allowBranch: [main, release/*]
+
+group: true # implicit repo-wide version group by default
+
+version:
+  commitMessage: 'chore(release): v{version}'
+
+changelog:
+  ignoreTypes: [chore, ci]
+  tagPattern: 'v*'
+
+run:
+  build:
+    concurrency: 4
+  lint:
+    topo: false
+    bail: false
+  test:
+    changedSince: v1.0.0
+```
+
+```json
+// packages/core/.rmanrc - this one package overrides just its own group
+{ "group": false }
+```
+
+```json
+// packages/plugin-a/.rmanrc - versions together with plugin-b, independent of everyone else
+{ "group": "plugins" }
+```
+
+See [docs/api.md#configuration-rmanrc-rmanyml](docs/api.md#configuration-rmanrc-rmanyml) for the
+full key reference (every `run.<script>.*` sub-key, `clean.*`, `changelog.*`, precedence rules,
+and which keys are root-level-only today).
+
+## Programmatic API
+
+Every command above is a thin wrapper around an exported service function - call them directly
+from your own Node.js scripts without shelling out to the `rman` binary:
+
+```ts
+import { Repository, VersionService } from 'rman';
+
+const repository = Repository.create();
+const plan = await VersionService.getPlan(repository);
+await VersionService.applyPlan(repository, plan, { changelog: true, push: true });
+```
 
+Full reference, with detailed examples for every service (`VersionService`, `PublishService`,
+`ChangelogService`, `RunService`, `CiService`, `CleanService`, `ExecService`, `ListService`,
+`ImportService`, `SystemInfo`) and the `Repository`/`Package` core classes: **[docs/api.md](docs/api.md)**.
 
-Monorepo repository manager
+## Node compatibility
 
-## Node Compatibility
+- Node.js >= 20
 
-- node >= 14.x
+## License
 
-### License
-rman is available under [MIT](LICENSE) license.
+rman is available under the [MIT](LICENSE) license.
 
 [npm-image]: https://img.shields.io/npm/v/rman.svg
 [npm-url]: https://npmjs.org/package/rman
-[travis-image]: https://img.shields.io/travis/panates/rman/master.svg
-[travis-url]: https://travis-ci.com/panates/rman
-[coveralls-image]: https://img.shields.io/coveralls/panates/rman/master.svg
-[coveralls-url]: https://coveralls.io/r/panates/rman
 [downloads-image]: https://img.shields.io/npm/dm/rman.svg
 [downloads-url]: https://npmjs.org/package/rman
-[gitter-image]: https://badges.gitter.im/panates/rman.svg
-[gitter-url]: https://gitter.im/panates/rman?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-[dependencies-image]: https://david-dm.org/panates/rman/status.svg
-[dependencies-url]:https://david-dm.org/panates/rman
-[devdependencies-image]: https://david-dm.org/panates/rman/dev-status.svg
-[devdependencies-url]:https://david-dm.org/panates/rman?type=dev
-[quality-image]: http://npm.packagequality.com/shield/rman.png
-[quality-url]: http://packagequality.com/#?package=rman
+[qc-image]: https://github.com/panates/rman/actions/workflows/qc.yml/badge.svg
+[qc-url]: https://github.com/panates/rman/actions/workflows/qc.yml
+[license-image]: https://img.shields.io/npm/l/rman.svg
+[license-url]: https://github.com/panates/rman/blob/main/LICENSE

package/cli.d.ts

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 export declare function runCli(options?: {
     argv?: string[];
     cwd?: string;

package/cli.js

@@ -1,30 +1,42 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import colors from 'ansi-colors';
 import yargs from 'yargs';
-import { BuildCommand } from './commands/build-command.js';
-import { ChangedCommand } from './commands/changed-command.js';
-import { CleanInstallCommand } from './commands/ci-command.js';
-import { ExecuteCommand } from './commands/execute-command.js';
-import { InfoCommand } from './commands/info-command.js';
-import { ListCommand } from './commands/list-command.js';
-import { PublishCommand } from './commands/publish-command.js';
-import { RunCommand } from './commands/run-command.js';
-import { VersionCommand } from './commands/version-command.js';
+import { hideBin } from 'yargs/helpers';
+import * as buildCommand from './commands/build.command.js';
+import * as changedCommand from './commands/changed.command.js';
+import * as changelogCommand from './commands/changelog.command.js';
+import * as ciCommand from './commands/ci.command.js';
+import * as cleanCommand from './commands/clean.command.js';
+import * as diffCommand from './commands/diff.command.js';
+import * as execCommand from './commands/exec.command.js';
+import * as importCommand from './commands/import.command.js';
+import * as infoCommand from './commands/info.command.js';
+import * as listCommand from './commands/list.command.js';
+import * as publishCommand from './commands/publish.command.js';
+import * as runCommand from './commands/run.command.js';
+import * as testCommand from './commands/test.command.js';
+import * as versionCommand from './commands/version.command.js';
 import { version } from './constants.js';
-import { Command } from './core/command.js';
 import { Repository } from './core/repository.js';
+import { LOG_LEVELS } from './utils/logger.js';
 export async function runCli(options) {
     try {
         const repository = Repository.create(options?.cwd);
-        const _argv = options?.argv || process.argv.slice(2);
-        const globalKeys = Object.keys(Command.globalOptions).concat(['help', 'version']);
+        const _argv = options?.argv || hideBin(process.argv);
         const program = yargs(_argv)
-            // .scriptName('rman')
-            .strict()
+            .scriptName('rman2')
             .version(version)
             .alias('version', 'v')
             .usage('$0 <cmd> [options...]')
             .help('help')
             .alias('help', 'h')
+            .option('log-level', {
+            describe: 'Default verbosity of the per-step log for run/build/ci (default: info, or .rmanrc "logLevel"; ' +
+                'overridable per-package via .rmanrc run.<script>.logLevel)',
+            choices: LOG_LEVELS,
+        })
             .showHelpOnFail(false, 'Run with --help for available options')
             .fail((msg, err) => {
             if (!err?.logged) {
@@ -38,19 +50,22 @@ export async function runCli(options) {
             }
             else
                 process.exit(1);
-        })
-            // group options under "Global Options:" header
-            .options(Command.globalOptions)
-            .group(globalKeys, 'Global Options:');
-        InfoCommand.initCli(repository, program);
-        ListCommand.initCli(repository, program);
-        ChangedCommand.initCli(repository, program);
-        ExecuteCommand.initCli(repository, program);
-        RunCommand.initCli(repository, program);
-        VersionCommand.initCli(repository, program);
-        PublishCommand.initCli(repository, program);
-        CleanInstallCommand.initCli(repository, program);
-        BuildCommand.initCli(repository, program);
+        });
+        infoCommand.initCli(repository, program);
+        listCommand.initCli(repository, program);
+        runCommand.initCli(repository, program);
+        buildCommand.initCli(repository, program);
+        ciCommand.initCli(repository, program);
+        cleanCommand.initCli(repository, program);
+        changelogCommand.initCli(repository, program);
+        testCommand.initCli(repository, program);
+        versionCommand.initCli(repository, program);
+        publishCommand.initCli(repository, program);
+        execCommand.initCli(repository, program);
+        changedCommand.initCli(repository, program);
+        diffCommand.initCli(repository, program);
+        importCommand.initCli(repository, program);
+        program.demandCommand(1).strict().completion();
         if (!_argv.length)
             program.showHelp();
         else
@@ -58,6 +73,15 @@ export async function runCli(options) {
     }
     catch (e) {
         console.error(colors.red(e.message));
-        // logger.error('rman', e.message);
     }
 }
+function isMain() {
+    try {
+        return !!process.argv[1] && realpathSync(fileURLToPath(import.meta.url)) === realpathSync(process.argv[1]);
+    }
+    catch {
+        return false;
+    }
+}
+if (isMain())
+    runCli().catch(() => 0);

package/commands/build.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/build.command.js

@@ -0,0 +1,14 @@
+import { RunService } from '../services/run.service.js';
+import { assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
+import { applyRunOptions, readRunOptions } from './run.command.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'build',
+        describe: 'Alias for "run build"',
+        builder: cmd => applyRunOptions(cmd).example('$0 build', '# Builds packages'),
+        handler: async (args) => {
+            await assertAllowedBranch(repository, readBranchGuardOptions(args));
+            await RunService.runScript(repository, 'build', { ...readRunOptions(args), commandName: 'build' });
+        },
+    });
+}

package/commands/changed.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/changed.command.js

@@ -0,0 +1,29 @@
+import colors from 'ansi-colors';
+import { VersionService } from '../services/version.service.js';
+import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'changed',
+        describe: 'Shows which packages the next "version" run would bump, without changing anything',
+        builder: cmd => applyPackageFilterOptions(cmd).example('$0 changed', '').example('$0 changed --json', '').option('json', {
+            alias: 'j',
+            describe: 'Print output as JSON',
+            type: 'boolean',
+        }),
+        handler: async (args) => {
+            const plan = await VersionService.getPlan(repository, readPackageFilterOptions(args));
+            const changed = plan.filter(e => e.status === 'bump');
+            if (args.json) {
+                console.log(JSON.stringify(changed.map(e => ({ name: e.package.name, group: e.group, from: e.from, to: e.to, reason: e.reason })), undefined, 2));
+                return;
+            }
+            if (!changed.length) {
+                console.log(colors.gray('Nothing has changed.'));
+                return;
+            }
+            for (const e of changed) {
+                console.log(colors.green('changed'), colors.cyan(e.package.name), colors.gray(`(${e.group})`), e.from, '->', colors.yellow(e.to));
+            }
+        },
+    });
+}

package/commands/changelog.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/changelog.command.js

@@ -0,0 +1,63 @@
+import colors from 'ansi-colors';
+import { ChangelogService } from '../services/changelog.service.js';
+import { Logger, resolveRootLogLevel } from '../utils/logger.js';
+import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'changelog',
+        describe: 'Generates a changelog per package from unreleased commits',
+        builder: cmd => applyPackageFilterOptions(cmd)
+            .example('$0 changelog', "# Auto-detects each package's last published version on npm")
+            .example('$0 changelog --from <hash> --write', '# Since a specific commit, written to file')
+            .option('from', {
+            describe: 'Generate the changelog since this commit/hash, applied the same way to every package. ' +
+                'Default (also "npm" explicitly): auto-detect per package from its published npm version, ' +
+                "falling back to not-yet-pushed commits for a package that can't be resolved this way",
+            type: 'string',
+        })
+            .option('write', {
+            describe: "Prepend the entry into each package's own changelog file instead of printing it",
+            type: 'boolean',
+        })
+            .option('file-path', {
+            describe: "With --write, the file to prepend into, relative to each package's own directory " +
+                '(default: "CHANGELOG.md", or .rmanrc "changelog.filePath")',
+            type: 'string',
+        })
+            .option('root', {
+            alias: 'r',
+            describe: 'Generate for the whole repository even when the current directory is inside a single ' +
+                'package (which otherwise scopes it to just that package). No effect elsewhere.',
+            type: 'boolean',
+        }),
+        handler: async (args) => {
+            const from = args.from;
+            const write = args.write;
+            const logger = new Logger(args.logLevel ?? resolveRootLogLevel(repository));
+            if (!from || from === 'npm') {
+                // A network round trip per package, even run concurrently, can still take a visible
+                // moment - without this, the command looks hung for that stretch instead of just busy.
+                logger.info(colors.gray('Checking published npm versions...'));
+            }
+            const options = {
+                ...readPackageFilterOptions(args),
+                from,
+                filePath: args.filePath,
+                root: args.root,
+            };
+            const entries = args.write
+                ? await ChangelogService.generateToFile(repository, options)
+                : await ChangelogService.getEntries(repository, options);
+            if (!entries.length) {
+                logger.info(colors.gray('No unreleased changes.'));
+                return;
+            }
+            for (const entry of entries) {
+                if (write)
+                    logger.info(colors.green('updated'), colors.cyan(entry.label), entry.filePath);
+                else
+                    console.log(entry.content);
+            }
+        },
+    });
+}

package/commands/ci.command.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+import type { Repository } from '../core/repository.js';
+export declare function initCli(repository: Repository, program: Argv): void;

package/commands/ci.command.js

@@ -0,0 +1,30 @@
+import { CiService } from '../services/ci.service.js';
+import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
+import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'ci',
+        describe: 'Deletes node_modules and lockfiles in every package, then reinstalls from scratch',
+        builder: cmd => applyBranchGuardOptions(applyPackageFilterOptions(cmd))
+            .example('$0 ci', '')
+            .option('package-manager', {
+            describe: 'Package manager to install with (default: npm, or .rmanrc "packageManager")',
+            choices: PACKAGE_MANAGERS,
+        })
+            .option('progress', {
+            describe: 'Show a live progress panel while running (default: true; auto-disabled when not a TTY). ' +
+                'Unlike run/build, completion is not reported as a per-package tally - only failures are called out.',
+            type: 'boolean',
+        }),
+        handler: async (args) => {
+            await assertAllowedBranch(repository, readBranchGuardOptions(args));
+            await CiService.reinstall(repository, {
+                ...readPackageFilterOptions(args),
+                packageManager: args.packageManager,
+                progress: args.progress,
+                logLevel: args.logLevel,
+            });
+        },
+    });
+}
+const PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm', 'bun'];