rman 2.12.0 → 2.14.0

package/builtins/publish-targets/npm/npm-publish-target.js

@@ -79,6 +79,10 @@ export class NpmPublishTarget {
     skipReason(pkg) {
         return PublishService.skipReason(pkg);
     }
+    /** The registry's host where `publishConfig.registry` names one other than npm's own. */
+    labelFor(pkg) {
+        return PublishService.registryLabel(pkg);
+    }
     getPlan(ctx) {
         return PublishService.getPlan(ctx.repository, this.planOptions(ctx));
     }

package/builtins/publish-targets/npm/npm-view.d.ts

@@ -46,3 +46,34 @@ export declare function npmViewVersion(name: string, cwd: string, options?: {
     registry?: string;
     userconfig?: string;
 }): Promise<string | undefined>;
+/** One published version, as `rman deps` needs it. */
+export interface NpmRelease {
+    version: string;
+    /** The deprecation message, when the version carries one. */
+    deprecated?: string;
+    peerDependencies?: Record<string, string>;
+    peerDependenciesMeta?: Record<string, {
+        optional?: boolean;
+    }>;
+    engines?: Record<string, string>;
+}
+/** What `rman deps` asks of the registry about one package name. */
+export interface NpmReleases {
+    /** Every version satisfying the range that was asked about, oldest first. */
+    releases: NpmRelease[];
+    /** The `latest` dist-tag. */
+    latest?: string;
+    /** When each version was published, when it was asked for. */
+    time?: Record<string, string>;
+}
+/**
+ * `npm view '<name>@<range>' version deprecated peerDependencies peerDependenciesMeta engines` plus
+ * the package's `dist-tags` (and `time`, when `withTime`) - two calls, run at once. `undefined` when
+ * the registry gave no answer at all.
+ *
+ * **Not catch-everything, unlike the two above.** A name the registry does not know is an answer
+ * `rman deps` has to report, not a state it can treat as "nothing newer".
+ */
+export declare function npmViewReleases(name: string, range: string, cwd: string, options?: {
+    withTime?: boolean;
+}): Promise<NpmReleases | undefined>;

package/builtins/publish-targets/npm/npm-view.js

@@ -63,9 +63,56 @@ export async function npmViewVersion(name, cwd, options = {}) {
         return undefined;
     }
 }
+/**
+ * `npm view '<name>@<range>' version deprecated peerDependencies peerDependenciesMeta engines` plus
+ * the package's `dist-tags` (and `time`, when `withTime`) - two calls, run at once. `undefined` when
+ * the registry gave no answer at all.
+ *
+ * **Not catch-everything, unlike the two above.** A name the registry does not know is an answer
+ * `rman deps` has to report, not a state it can treat as "nothing newer".
+ */
+/* **One call returns every version in the range.** npm answers a range with an array holding one
+ * object per matching version - measured at ~0.45s for a range covering dozens - so the cost is
+ * per name and not per version. A range matching exactly one version comes back as a bare object
+ * instead, which is why the result is normalized.
+ *
+ * `time` is a separate call because it is the whole package's history: thousands of entries for a
+ * package publishing nightlies, so it is fetched only when a minimum age asks for it. */
+export async function npmViewReleases(name, range, cwd, options = {}) {
+    const fields = ['version', 'deprecated', 'peerDependencies', 'peerDependenciesMeta', 'engines'];
+    const [releases, tags] = await Promise.all([
+        npmViewJson(['view', `${name}@${range}`, ...fields, '--json'], cwd),
+        npmViewJson(['view', name, 'dist-tags', ...(options.withTime ? ['time'] : []), '--json'], cwd),
+    ]);
+    if (tags === undefined)
+        return undefined;
+    const list = Array.isArray(releases) ? releases : releases ? [releases] : [];
+    const meta = (options.withTime ? tags : { 'dist-tags': tags });
+    return {
+        releases: list.filter((r) => typeof r?.version === 'string'),
+        latest: meta['dist-tags']?.latest,
+        time: meta.time,
+    };
+}
 function toVersionList(versions) {
     if (Array.isArray(versions))
         return versions;
     return versions ? [versions] : [];
 }
 const execFileAsync = promisify(execFile);
+/** `npm <argv>` parsed as JSON - `undefined` for a failed call, `null` for an empty answer (a range
+ *  no version satisfies). */
+async function npmViewJson(argv, cwd) {
+    try {
+        const { stdout } = await execFileAsync('npm', argv, { cwd, maxBuffer: 64 * 1024 * 1024 });
+        const text = stdout.trim();
+        return text ? JSON.parse(text) : null;
+    }
+    catch (e) {
+        /** A range nothing satisfies is answered with `E404 No match found` rather than an empty list. */
+        if (argv[1]?.includes('@', 1) && /No match found/.test(String(e?.stdout ?? '') + String(e?.stderr ?? ''))) {
+            return null;
+        }
+        return undefined;
+    }
+}

package/commands/deps.command.d.ts

@@ -0,0 +1,175 @@
+import type { RmanApplication } from '../core/application.js';
+import { type RmanConfig } from '../interfaces/rman-config.interface.js';
+/** Hoisted for `ArgsOf` - see `version.command.ts` and `RmanConfig.ArgsOf` for why. */
+declare const COMMAND: "deps [names..]";
+declare const config: {
+    scope: {
+        target: "cli";
+        describe: string;
+        type: "string";
+    };
+    ignore: {
+        target: "cli";
+        describe: string;
+        type: "string";
+    };
+    platform: {
+        target: "cli";
+        describe: string;
+        type: "string";
+    };
+    upgrade: {
+        target: "cli";
+        alias: string;
+        describe: string;
+        type: "boolean";
+    };
+    /** Its `choices` and its default are the version schemes' own sizes, so they are filled in where
+     *  the command is built - see `targetOption`. */
+    target: {
+        target: "both";
+        describe: string;
+        type: "string";
+    };
+    reject: {
+        target: "both";
+        describe: string;
+        type: "string";
+        array: true;
+    };
+    minAge: {
+        target: "both";
+        cliName: string;
+        describe: string;
+        type: "number";
+    };
+    types: {
+        target: "config";
+        describe: string;
+        type: "string";
+        array: true;
+    };
+    concurrency: {
+        target: "cli";
+        describe: string;
+        type: "number";
+    };
+    verify: {
+        target: "cli";
+        describe: string;
+        type: "boolean";
+    };
+    json: {
+        target: "cli";
+        alias: string;
+        describe: string;
+        type: "boolean";
+    };
+};
+type Args = RmanConfig.ArgsOf<typeof config, typeof COMMAND>;
+/**
+ * `rman deps` - which dependencies have a newer version, and with `--upgrade`, moving them there.
+ *
+ * A version is offered only when every rule that can be seen allows it: the package's own
+ * `deps.target`/`reject`/`minAge`, the peer ranges of the other dependencies it names, the runtime
+ * the package supports, and what its sibling packages ask of a shared dependency. Each version held
+ * back is printed with the rule that held it.
+ */
+declare const depsCommand: (app: RmanApplication) => {
+    command: "deps [names..]";
+    describe: string;
+    config: {
+        target: {
+            target: "both";
+            describe: string;
+            type: "string";
+        } & {
+            choices: string[];
+        };
+        scope: {
+            target: "cli";
+            describe: string;
+            type: "string";
+        };
+        ignore: {
+            target: "cli";
+            describe: string;
+            type: "string";
+        };
+        platform: {
+            target: "cli";
+            describe: string;
+            type: "string";
+        };
+        upgrade: {
+            target: "cli";
+            alias: string;
+            describe: string;
+            type: "boolean";
+        };
+        reject: {
+            target: "both";
+            describe: string;
+            type: "string";
+            array: true;
+        };
+        minAge: {
+            target: "both";
+            cliName: string;
+            describe: string;
+            type: "number";
+        };
+        types: {
+            target: "config";
+            describe: string;
+            type: "string";
+            array: true;
+        };
+        concurrency: {
+            target: "cli";
+            describe: string;
+            type: "number";
+        };
+        verify: {
+            target: "cli";
+            describe: string;
+            type: "boolean";
+        };
+        json: {
+            target: "cli";
+            alias: string;
+            describe: string;
+            type: "boolean";
+        };
+    };
+    positionals: {
+        names: {
+            describe: string;
+            type: "string";
+        };
+    };
+    examples: {
+        command: string;
+        description: string;
+    }[];
+    handler: (args: Args) => Promise<void>;
+};
+export default depsCommand;
+/** The rest of `deps.*` - what an option cannot describe. */
+export interface DepsExtraKeys {
+    /**
+     * The largest move for the dependencies a glob matches, ahead of `target` - a package that
+     * releases a major every few weeks, or one that has stayed on `0.x` for years, where a `0.x`
+     * minor counts as a major. The last glob matching a name wins.
+     *
+     * @example { "@types/node": "major", "esbuild": "major" }
+     */
+    targets?: Record<string, string>;
+}
+/** `deps`'s own keys on `RmanConfig`: derived from the `config` block, plus `DepsExtraKeys`. */
+declare module '../interfaces/rman-config.interface.js' {
+    namespace RmanConfig {
+        interface CommandConfigs extends RmanConfig.CommandContribution<ReturnType<typeof depsCommand>, DepsExtraKeys> {
+        }
+    }
+}

package/commands/deps.command.js

@@ -0,0 +1,252 @@
+import path from 'node:path';
+import colors from 'ansi-colors';
+import { semverScheme } from '../core/classes/version-scheme.js';
+import { DependencyUpdater } from '../core/interfaces/dependency-updater.js';
+import { registerCommand } from '../interfaces/rman-config.interface.js';
+import { filterPackages, packageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+/** Hoisted for `ArgsOf` - see `version.command.ts` and `RmanConfig.ArgsOf` for why. */
+const COMMAND = 'deps [names..]';
+const { scope, ignore, platform } = packageFilterOptions;
+const config = {
+    /* `--deps`/`--dependents` are left out: on a command called `deps`, `rman deps --deps` would read
+     * as something other than "and the packages these depend on". */
+    scope,
+    ignore,
+    platform,
+    upgrade: {
+        target: 'cli',
+        alias: 'u',
+        describe: 'Write the new ranges to the manifests, then check that they still install',
+        type: 'boolean',
+    },
+    /** Its `choices` and its default are the version schemes' own sizes, so they are filled in where
+     *  the command is built - see `targetOption`. */
+    target: {
+        target: 'both',
+        describe: 'The largest move a dependency may make',
+        type: 'string',
+    },
+    reject: {
+        target: 'both',
+        describe: 'Leave the dependencies matching these globs alone (repeatable)',
+        type: 'string',
+        array: true,
+    },
+    minAge: {
+        target: 'both',
+        cliName: 'min-age',
+        describe: 'Only move to a version published at least this many days ago',
+        type: 'number',
+    },
+    types: {
+        target: 'config',
+        describe: "The dependency kinds to look at, in the ecosystem's own words - default: every kind",
+        type: 'string',
+        array: true,
+    },
+    concurrency: {
+        target: 'cli',
+        describe: `How many registry lookups run at once (default: ${defaultConcurrency()})`,
+        type: 'number',
+    },
+    verify: {
+        target: 'cli',
+        describe: "After --upgrade, ask the ecosystem's own resolver whether the result installs (default: true)",
+        type: 'boolean',
+    },
+    json: {
+        target: 'cli',
+        alias: 'j',
+        describe: 'Print the plan as JSON - one entry per package and dependency',
+        type: 'boolean',
+    },
+};
+/**
+ * `rman deps` - which dependencies have a newer version, and with `--upgrade`, moving them there.
+ *
+ * A version is offered only when every rule that can be seen allows it: the package's own
+ * `deps.target`/`reject`/`minAge`, the peer ranges of the other dependencies it names, the runtime
+ * the package supports, and what its sibling packages ask of a shared dependency. Each version held
+ * back is printed with the rule that held it.
+ */
+/* **The command is the core's and the answer is the technology's** - see `DependencyUpdater`. A
+ * package whose platform has no updater is left alone, which in a polyglot repository is the right
+ * answer for the half rman cannot speak for. */
+const depsCommand = registerCommand(app => {
+    const repository = app.repository;
+    return {
+        command: COMMAND,
+        describe: 'Lists the dependencies that have a newer version - pass -u to upgrade them',
+        config: { ...config, target: targetOption(app) },
+        positionals: {
+            names: { describe: 'Only these dependencies (globs)', type: 'string' },
+        },
+        examples: [
+            { command: '$0 deps', description: '# What could move, and what holds it back' },
+            { command: '$0 deps -u', description: '# Write the new ranges, then check that they install' },
+            { command: '$0 deps --target major', description: '# Across a major too' },
+            { command: '$0 deps "@types/*"', description: '# Only the dependencies matching this glob' },
+        ],
+        handler: async (args) => {
+            const options = {
+                names: args.names?.length ? args.names.map(String) : undefined,
+                target: args.target,
+                reject: args.reject?.map(String),
+                minAge: args.minAge,
+                concurrency: Math.max(1, args.concurrency ?? defaultConcurrency()),
+            };
+            const ctx = { app, repository, options };
+            /** The root holds a monorepo's shared tooling, so it is asked too. */
+            const candidates = repository.monorepo ? [repository.rootPackage, ...repository.packages] : repository.packages;
+            const selected = filterPackages([...candidates], readPackageFilterOptions(args));
+            if (!selected.length)
+                throw logged('No package matched.');
+            const byUpdater = new Map();
+            for (const pkg of selected) {
+                const updater = pkg.platform.dependencyUpdater;
+                if (!updater)
+                    continue;
+                byUpdater.set(updater, [...(byUpdater.get(updater) ?? []), pkg]);
+            }
+            if (!byUpdater.size) {
+                throw logged('None of the selected packages belongs to a technology that can update its dependencies.');
+            }
+            const plans = new Map();
+            for (const [updater, packages] of byUpdater)
+                plans.set(updater, await updater.getPlan(ctx, packages));
+            const all = [...plans.values()].flat();
+            if (args.json)
+                console.log(JSON.stringify(jsonPlan(all), undefined, 2));
+            else
+                printPlan(all, repository.dirname);
+            const errors = all.filter(e => e.status === 'error');
+            const updates = all.filter(e => e.status === 'update');
+            if (!args.upgrade) {
+                if (updates.length && !args.json)
+                    console.log(colors.gray('\nRun "rman deps -u" to upgrade.'));
+                if (errors.length)
+                    throw logged(`${errors.length} dependency lookup(s) failed - see above.`);
+                return;
+            }
+            const applied = [];
+            for (const [updater, plan] of plans) {
+                if (plan.some(e => e.status === 'update'))
+                    applied.push(await updater.applyPlan(ctx, plan));
+            }
+            const files = applied.flatMap(a => a.files);
+            if (files.length && args.verify !== false) {
+                for (const [updater, packages] of byUpdater) {
+                    const refused = await updater.verify?.(ctx, packages);
+                    if (!refused)
+                        continue;
+                    for (const a of applied)
+                        a.restore();
+                    throw logged(`The upgraded manifests do not install, so they were put back:\n${refused}`);
+                }
+            }
+            if (!args.json) {
+                for (const file of files)
+                    console.log(colors.green('updated'), path.relative(repository.dirname, file));
+            }
+            if (errors.length)
+                throw logged(`${errors.length} dependency lookup(s) failed - see above.`);
+        },
+    };
+});
+export default depsCommand;
+/** Registry lookups are child processes waiting on the network, not CPU work, so the default is a
+ *  fixed number rather than the core count. */
+function defaultConcurrency() {
+    return 16;
+}
+/**
+ * `--target`: one of the version schemes' sizes, and by default every size but the largest.
+ *
+ * Read off the technologies this repository loaded rather than written down, because the sizes are
+ * a scheme's - semver's three are the only ones today.
+ */
+function targetOption(app) {
+    const schemes = [...app.platforms].map(p => p.manifestProvider.versionScheme ?? semverScheme);
+    const sizes = [...new Set((schemes.length ? schemes : [semverScheme]).flatMap(s => s.bumpNames))];
+    const defaults = [...new Set(schemes.map(s => DependencyUpdater.defaultTarget(s.bumpNames)))];
+    return {
+        ...config.target,
+        describe: `${config.target.describe} (default: ${defaults.join(' / ') || DependencyUpdater.defaultTarget(semverScheme.bumpNames)})`,
+        choices: sizes,
+    };
+}
+function jsonPlan(entries) {
+    return entries.map(e => ({
+        package: e.package.name,
+        name: e.name,
+        types: e.types,
+        status: e.status,
+        current: e.current,
+        target: e.target,
+        latest: e.latest,
+        available: e.available,
+        bump: e.bump,
+        reason: e.reason,
+    }));
+}
+/**
+ * One block per package with something to say: what moves, grouped by size, smallest first - and
+ * then **what does not**, each with the reason it stays.
+ */
+/* **The second half is the one `npm-check-updates` taught people to read.** Under `--target minor`
+ * a major that was left behind has to be on the screen, or a run reporting three patches looks like
+ * a repository that is current. A dependency that moved but not as far as it could appears in both:
+ * once under its size, once under "not updated" with what held it. */
+function printPlan(entries, root) {
+    const updated = entries.filter(e => e.status === 'update');
+    const behind = entries.filter(e => e.status === 'held' || e.status === 'skipped' || e.status === 'error' || (e.status === 'update' && e.reason));
+    if (!updated.length && !behind.length) {
+        console.log(colors.gray('Every dependency is up to date.'));
+        return;
+    }
+    const shown = [...updated, ...behind];
+    const nameWidth = Math.max(...shown.map(e => e.name.length));
+    const currentWidth = Math.max(...shown.map(e => e.current.length));
+    const row = (e, rest) => `    ${e.name.padEnd(nameWidth)}  ${e.current.padEnd(currentWidth)}  ${rest}`;
+    for (const pkg of [...new Set(shown.map(e => e.package))]) {
+        const where = path.relative(root, pkg.dirname);
+        console.log(colors.cyan(pkg.name) + (where ? colors.gray(` (${where})`) : ''));
+        const sizes = pkg.versionScheme.bumpNames;
+        for (const size of [...sizes, undefined]) {
+            const group = updated.filter(e => e.package === pkg && (size ? e.bump === size : !sizes.includes(e.bump)));
+            if (!group.length)
+                continue;
+            const paint = sizeColor(size, sizes);
+            console.log(`  ${paint(size ?? 'other')}`);
+            for (const e of group)
+                console.log(row(e, `→  ${paint(e.target ?? '')}`));
+        }
+        const left = behind.filter(e => e.package === pkg);
+        if (!left.length)
+            continue;
+        console.log(`  ${colors.yellow('not updated')}`);
+        const newest = (e) => (e.status === 'error' ? 'error' : (e.available ?? e.latest ?? ''));
+        const width = Math.max(...left.map(e => newest(e).length));
+        for (const e of left) {
+            const paint = e.status === 'error' ? colors.red : (text) => text;
+            console.log(row(e, `${paint(newest(e).padEnd(width))}  ${colors.gray(e.reason ?? '')}`));
+        }
+    }
+}
+/** The colours `npm-check-updates` uses - the largest size red, the next cyan, the rest green - read
+ *  off the scheme's own order so a scheme with other names still gets them. */
+function sizeColor(size, sizes) {
+    const rank = size ? sizes.indexOf(size) : -1;
+    if (rank === sizes.length - 1)
+        return colors.red;
+    if (rank === sizes.length - 2)
+        return colors.cyan;
+    return colors.green;
+}
+/** The `logged` convention: printed here, so `runCli`'s catch does not print it a second time. */
+function logged(message) {
+    console.error(colors.red(message));
+    const err = new Error(message);
+    err.logged = true;
+    return err;
+}

package/commands/list.command.js

@@ -2,6 +2,7 @@ import colors from 'ansi-colors';
 import EasyTable from 'easy-table';
 import { registerCommand } from '../interfaces/rman-config.interface.js';
 import { packageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
+import { isNamedGroupKey, isSoloGroupKey, ROOT_GROUP_KEY } from '../utils/version-group.js';
 /** `[options...]` is yargs-meaningless - its variadic marker is two dots, and this command declares
  *  no positional for it. Left as it is rather than fixed in passing: dropping it makes
  *  `rman list foo` start failing, which is a behaviour change and belongs in its own commit. */
@@ -82,8 +83,9 @@ const listCommand = registerCommand(app => {
              * so counting rows that are not the root reported `0 Package(s) found` there (measured). The
              * condition is the same one the service applies, and it is one line.
              */
+            /** Grouped, except where the order *is* the answer: `--toposort` is dependency order. */
             else
-                printTable(items, table && app.repository.monorepo);
+                printTable(args.toposort ? items : byGroup(items), table && app.repository.monorepo);
         },
     };
 });
@@ -100,10 +102,54 @@ function statusLabel(status) {
             return '';
     }
 }
-/** Where a package ships, one target name each - grey for a target `publish` would skip it for
- *  (`Item.skippedTargets`), so the column never reads as a promise the release will not keep. */
+/** Where a package ships, one target each - its label where it has one (`Item.targetLabels`, npm's
+ *  registry host). A target `publish` would skip it for (`Item.skippedTargets`) is left out, and a
+ *  package left with none reads `-`, so the column never reads as a promise the release will not
+ *  keep. Blank where no target claims the package at all - a monorepo's root, for one. */
 function publishLabel(it) {
-    return it.publishTargets.map(name => (it.skippedTargets[name] ? colors.gray(name) : colors.green(name))).join(', ');
+    if (!it.publishTargets.length)
+        return '';
+    const shipping = it.publishTargets.filter(name => !it.skippedTargets[name]);
+    if (!shipping.length)
+        return colors.gray('-');
+    return shipping.map(name => colors.green(it.targetLabels[name] ?? name)).join(', ');
+}
+/**
+ * The rows with each release group's members together - the root first, then the groups in the
+ * order their first member appears, then the packages in no group (`group: false`) - the order
+ * `version`'s plan prints them in. Stable within a group, so the lexical order holds there.
+ */
+/* The cost, stated: a package nested inside another can land away from it, when the two are in
+ * different groups - its indentation still says how deep it sits, not under which row. */
+function byGroup(items) {
+    const root = items.filter(it => it.groupKey === ROOT_GROUP_KEY);
+    const groups = new Map();
+    const solo = [];
+    for (const it of items) {
+        if (it.groupKey === ROOT_GROUP_KEY)
+            continue;
+        if (isSoloGroupKey(it.groupKey))
+            solo.push(it);
+        else
+            groups.set(it.groupKey, [...(groups.get(it.groupKey) ?? []), it]);
+    }
+    return [...root, ...[...groups.values()].flat(), ...solo];
+}
+/** Whether the Group column says anything: a group the repository named, or the default group
+ *  beside packages in none. One line for everything, or no grouping at all, would put the same
+ *  answer - or nothing - on every row. */
+function showsGroups(items) {
+    const keys = items.map(it => it.groupKey).filter(key => key !== ROOT_GROUP_KEY);
+    return keys.some(isNamedGroupKey) || (keys.includes('default') && keys.some(isSoloGroupKey));
+}
+/** A named group by its name, the default one as a grey `(default)` - `version`'s plan table reads
+ *  the same way. Blank for the root and for a package in no group. */
+function groupCell(it) {
+    if (isNamedGroupKey(it.groupKey))
+        return colors.cyan(it.group);
+    if (it.groupKey === 'default')
+        return colors.gray('(default)');
+    return '';
 }
 /**
  * **The tree, as a table**: the root first, then each package indented by how far below it sits.
@@ -125,10 +171,13 @@ function publishLabel(it) {
  */
 function printTable(items, withRoot) {
     const table = new EasyTable();
+    const withGroup = showsGroups(items);
     for (const it of items) {
         const indent = '  '.repeat(it.depth);
         table.cell('Package', indent + (it.isRoot ? colors.whiteBright(it.selector) : colors.yellowBright(it.selector)));
         table.cell('Version', colors.yellow(it.version));
+        if (withGroup)
+            table.cell('Group', groupCell(it));
         table.cell('Platform', it.platform ? colors.cyan(it.platform) : '');
         table.cell('Private', it.private ? colors.magentaBright('yes') : '');
         table.cell('Publish', publishLabel(it));

package/commands.d.ts

@@ -15,6 +15,7 @@
 import './commands/build.command.js';
 import './commands/changelog.command.js';
 import './commands/config.command.js';
+import './commands/deps.command.js';
 import './commands/diff.command.js';
 import './commands/exec.command.js';
 import './commands/github-release.command.js';
@@ -27,5 +28,6 @@ import './commands/test.command.js';
 import './commands/version.command.js';
 /** The config shapes a command declares by hand, where an option cannot describe them - see
  *  `RmanConfig.CommandContribution`'s `Extra`. Exported so a plugin can name one. */
+export type { DepsExtraKeys } from './commands/deps.command.js';
 export type { PublishExtraKeys, PublishTargetConfigs } from './commands/publish.command.js';
 export type { VersionExtraKeys, VersionStampEntry } from './commands/version.command.js';

package/commands.js

@@ -15,6 +15,7 @@
 import './commands/build.command.js';
 import './commands/changelog.command.js';
 import './commands/config.command.js';
+import './commands/deps.command.js';
 import './commands/diff.command.js';
 import './commands/exec.command.js';
 import './commands/github-release.command.js';

package/constants.js

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