rman 2.0.0-beta.2 → 2.0.0-beta.3

package/commands/version.command.js

@@ -42,6 +42,14 @@ const config = {
         type: 'boolean',
         conflicts: 'interactive',
     },
+    json: {
+        target: 'cli',
+        alias: 'j',
+        describe: 'Print the plan as JSON and write nothing - the machine-readable form of --show, and what ' +
+            'the removed "changed" command was for.',
+        type: 'boolean',
+        conflicts: ['interactive', 'yes'],
+    },
     ignoreDirty: {
         target: 'cli',
         cliName: 'ignore-dirty',
@@ -165,6 +173,38 @@ const versionCommand = registerCommand(app => {
                 ignoreDirty: args.ignoreDirty,
                 preid: args.preid,
             });
+            /**
+             * **The machine-readable plan, and the whole of it.** This replaced `rman changed`, which
+             * was `getPlan` filtered to `status === 'bump'` - and that one-line filter produced two
+             * silent wrongs at once, measured together on a dirty tree: the entry it returned was the
+             * repository **root** (`buildRootEntry` reports `'bump'`, and the fact that it is
+             * informational lived only in `reason`), while `pkg-a`, the package that had actually
+             * changed, was dropped because a package with uncommitted changes is `'error'`. A CI script
+             * reading that array saw one name to release and it was the one name that must never be
+             * published.
+             *
+             * So nothing is filtered here. Every entry carries its own `status`, and `isRoot` is stated
+             * rather than left to be inferred from `group === "root"` - a consumer selects what it wants
+             * and can see what it is leaving out. Printed **before** the table and before the
+             * dirty-package throw, so stdout holds one JSON document and nothing else.
+             *
+             * **Exit 0 either way, deliberately.** `--show` exits 1 on a dirty package because a person
+             * needs stopping; here the same fact is in the data, and overloading the exit code would
+             * make a pipeline bail before it could read the very rows that explain why.
+             */
+            if (args.json) {
+                console.log(JSON.stringify(plan.map(e => ({
+                    name: e.package.name,
+                    selector: e.package.selector,
+                    isRoot: e.package.isRoot,
+                    group: e.group,
+                    status: e.status,
+                    from: e.from,
+                    to: e.to,
+                    reason: e.reason,
+                })), undefined, 2));
+                return;
+            }
             printPlan(plan);
             const errors = plan.filter(e => e.status === 'error');
             if (errors.length) {
@@ -236,18 +276,112 @@ function printApplied(result) {
 }
 function printPlan(entries) {
     const table = new EasyTable();
-    for (const e of entries) {
-        table.cell('Status', statusLabel(e.status));
-        table.cell('Package', colors.cyan(e.package.name));
-        table.cell('Group', colors.gray(`(${e.group})`));
-        table.cell('From', e.from);
-        table.cell('', e.status === 'bump' ? '->' : '');
-        table.cell('To', e.status === 'bump' ? colors.yellow(e.to) : '');
-        table.cell('Reason', e.status === 'error' ? colors.red(e.reason ?? '') : colors.gray(e.reason ?? ''));
-        table.newRow();
+    let first = true;
+    for (const { members, shared } of planBlocks(entries)) {
+        if (!first)
+            table.pushDelimeter(PLAN_COLUMNS);
+        first = false;
+        for (const e of members)
+            printPlanRow(table, e, shared);
     }
     console.log(table.toString().trim());
 }
+/**
+ * The plan, split into the blocks a delimiter is drawn between: the **repository root** first, then
+ * every shared version line with its members together, then the packages that share a line with
+ * nobody.
+ *
+ * `getPlan` returns entries in *package* order, which is the order the workspace found them in -
+ * so two members of one group are adjacent only by luck. That matters more than it looks: a group
+ * releases as one version line, so "these four numbers move together" is the single fact the table
+ * exists to convey, and scattering the members leaves the `Group` column as the only thing saying
+ * so. Read top to bottom instead, each block now *is* a release.
+ *
+ * **The root is first, and it is the one row that is not a release.** Its number is the
+ * repository's identity - what the GitHub Release is named after, and on a calendar version a
+ * number no package shares - so it is the heading the rest of the table sits under rather than a
+ * footnote to it. `buildRootEntry` appends it, which is why it is pulled out by hand here; leaving
+ * it where the plan put it made it the last singleton, indistinguishable from a package that
+ * happens to be grouped with no one.
+ *
+ * **Solo packages are one block, not one block each.** `group: false` makes every package its own
+ * group of one, so a delimiter per group would draw a line between every row in exactly the
+ * repository that has nothing to group - noise standing in for structure. They share a block
+ * because what they have in common is real: none of them is tied to anyone else.
+ *
+ * `shared` travels with each block because it is also what decides whether the `Group` column is
+ * written at all - see `printPlanRow`. One partition, asked once, answering both questions; working
+ * it out again at the cell would be a second rule that could disagree with the blocks beside it.
+ */
+function planBlocks(entries) {
+    /**
+     * `package.isRoot` is by **directory**, which is the only reliable test - `Repository extends
+     * Package` while holding a separate `rootPackage` instance for the same directory, so an identity
+     * check answers `false` for one of the two objects that are both the root.
+     *
+     * In a single-package repository that one package *is* the root and `getPlan` pushes no root
+     * entry of its own, so it lands here and prints alone - one row, and no delimiter to draw.
+     */
+    const root = entries.filter(e => e.package.isRoot);
+    const members = entries.filter(e => !e.package.isRoot);
+    const byGroup = new Map();
+    for (const e of members) {
+        const group = byGroup.get(e.groupKey);
+        if (group)
+            group.push(e);
+        else
+            byGroup.set(e.groupKey, [e]);
+    }
+    const shared = [];
+    const solo = [];
+    for (const group of byGroup.values()) {
+        if (group.length > 1)
+            shared.push({ members: group, shared: true });
+        else
+            solo.push(group[0]);
+    }
+    return [
+        ...(root.length ? [{ members: root, shared: false }] : []),
+        ...shared,
+        ...(solo.length ? [{ members: solo, shared: false }] : []),
+    ];
+}
+/** `buildRootEntry`'s display label. Named here because `printPlanRow` has to recognize the one
+ *  singleton whose group is worth printing, and a bare `'root'` in a condition reads as a guess. */
+const ROOT_GROUP = 'root';
+/** The column names in the order `printPlanRow` writes them - `pushDelimeter` has to be handed the
+ *  same set, or the dashes appear under a column that does not exist yet. */
+const PLAN_COLUMNS = ['Status', 'Package', 'Group', 'From', '', 'To', 'Reason'];
+function printPlanRow(table, e, shared) {
+    table.cell('Status', statusLabel(e.status));
+    table.cell('Package', colors.cyan(e.package.name));
+    /**
+     * **Blank for a package that shares its version line with nobody.** `resolveGroupKey` gives an
+     * ungrouped package a group of one named after the package, so the cell printed the Package
+     * column again, one column to the right - a word that looks like information and carries none.
+     * Worse, it made `(default)` and `(@panates/tsconfig)` read as the same *kind* of answer when one
+     * names a line four packages move along and the other names nothing at all.
+     *
+     * The root keeps its label: `root` is not its package name but what the row *is*, and it is the
+     * only thing on the line saying that the number below is the repository's identity rather than a
+     * release. So the test is `shared`, plus that one entry - not "does this string repeat the name",
+     * which would blank a genuine group that happened to be called after one of its members.
+     */
+    table.cell('Group', shared || e.group === ROOT_GROUP ? colors.gray(`(${e.group})`) : '');
+    table.cell('From', e.from);
+    /**
+     * Gated on `to`, not on `status === 'bump'`, which is what kept the column blank on the one
+     * command whose whole job is to fill it: a dirty package aborts the run, and "you cannot
+     * release this" is only half of what the reader came for - the other half is which version it
+     * would have got. `getPlan` sets `to` on exactly the entries that earned one, so asking whether
+     * there is a version to show is the honest test. Dimmed rather than yellow when the entry is
+     * not a bump, because that number is a hypothetical and nothing is going to write it.
+     */
+    table.cell('', e.to ? '->' : '');
+    table.cell('To', e.to ? (e.status === 'bump' ? colors.yellow(e.to) : colors.gray(e.to)) : '');
+    table.cell('Reason', e.status === 'error' ? colors.red(e.reason ?? '') : colors.gray(e.reason ?? ''));
+    table.newRow();
+}
 function statusLabel(status) {
     switch (status) {
         case 'bump':

package/commands.d.ts

@@ -13,7 +13,6 @@
  * being hand-written centrally, in what is now `rman-config.interface.ts`).
  */
 import './commands/build.command.js';
-import './commands/changed.command.js';
 import './commands/changelog.command.js';
 import './commands/config.command.js';
 import './commands/diff.command.js';
@@ -21,6 +20,7 @@ import './commands/exec.command.js';
 import './commands/github-release.command.js';
 import './commands/import.command.js';
 import './commands/info.command.js';
+import './commands/lint.command.js';
 import './commands/list.command.js';
 import './commands/publish.command.js';
 import './commands/run.command.js';

package/commands.js

@@ -13,7 +13,6 @@
  * being hand-written centrally, in what is now `rman-config.interface.ts`).
  */
 import './commands/build.command.js';
-import './commands/changed.command.js';
 import './commands/changelog.command.js';
 import './commands/config.command.js';
 import './commands/diff.command.js';
@@ -21,6 +20,7 @@ import './commands/exec.command.js';
 import './commands/github-release.command.js';
 import './commands/import.command.js';
 import './commands/info.command.js';
+import './commands/lint.command.js';
 import './commands/list.command.js';
 import './commands/publish.command.js';
 import './commands/run.command.js';

package/constants.js

@@ -1 +1 @@
-export const version = '2.0.0-beta.2';
+export const version = '2.0.0-beta.3';

package/core/application.d.ts

@@ -1,10 +1,10 @@
 import type { VersionPlanService } from '../services/version-plan.service.js';
 import { Logger, type LogLevel } from '../utils/logger.js';
-import { type Platform, type Plugin } from './plugin.js';
-import type { PublishTarget } from './publish-target.js';
-import { Registry } from './registry.js';
-import type { Repository } from './repository.js';
-import type { ServiceFactory, ServiceMap } from './service.js';
+import { Registry } from './classes/registry.js';
+import type { Repository } from './classes/repository.js';
+import type { ServiceFactory, ServiceMap } from './classes/service.js';
+import { type Platform, type Plugin } from './interfaces/plugin.js';
+import type { PublishTarget } from './interfaces/publish-target.js';
 /**
  * **One rman invocation, and everything it holds.** Created before anything else, handed to every
  * plugin's `init`, and the owner of every registry and service that used to be a module-level
@@ -62,6 +62,11 @@ export declare class RmanApplication {
      */
     versionPlanner?: VersionPlanService;
     readonly logger: Logger;
+    /** `info` until `--log-level` or `.rmanrc "logLevel"` is resolved - which cannot happen here,
+     *  since reading the config is itself work the application does. */
+    constructor(options?: {
+        logLevel?: LogLevel;
+    });
     /** Which platform claims a directory - the first whose manifest provider recognizes it, because
      *  before a package is read there is nothing else to go on. `basePlatform` when none does, so the
      *  caller needs no guard. */
@@ -76,11 +81,6 @@ export declare class RmanApplication {
      * made a real mistake, and `undefined` would let it write a check that silently does nothing.
      */
     get repository(): Repository;
-    /** `info` until `--log-level` or `.rmanrc "logLevel"` is resolved - which cannot happen here,
-     *  since reading the config is itself work the application does. */
-    constructor(options?: {
-        logLevel?: LogLevel;
-    });
     /**
      * The single instance of a service, built on first use.
      *

package/core/application.js

@@ -1,8 +1,15 @@
+import { DockerPublishService, dockerPublishTarget } from '../builtins/publish-targets/docker/index.js';
+import { ChangelogService } from '../services/changelog.service.js';
+import { ConfigService } from '../services/config-service.js';
+import { ExecService } from '../services/exec.service.js';
+import { GithubReleaseService } from '../services/github-release.service.js';
+import { ImportService } from '../services/import.service.js';
+import { ListService } from '../services/list.service.js';
+import { RunService } from '../services/run.service.js';
+import { VersionService } from '../services/version.service.js';
 import { Logger } from '../utils/logger.js';
-import { registerCoreServices } from './core-services.js';
-import { registerCoreTargets } from './core-targets.js';
-import { basePlatform } from './plugin.js';
-import { Registry } from './registry.js';
+import { Registry } from './classes/registry.js';
+import { basePlatform } from './interfaces/plugin.js';
 /**
  * **One rman invocation, and everything it holds.** Created before anything else, handed to every
  * plugin's `init`, and the owner of every registry and service that used to be a module-level
@@ -60,6 +67,23 @@ export class RmanApplication {
      */
     versionPlanner;
     logger;
+    /** `info` until `--log-level` or `.rmanrc "logLevel"` is resolved - which cannot happen here,
+     *  since reading the config is itself work the application does. */
+    constructor(options) {
+        this.logger = new Logger(options?.logLevel ?? 'info');
+        // Register core services.
+        this.setService('config', a => new ConfigService(a));
+        this.setService('changelog', a => new ChangelogService(a));
+        this.setService('dockerPublish', a => new DockerPublishService(a));
+        this.setService('githubRelease', a => new GithubReleaseService(a));
+        this.setService('exec', a => new ExecService(a));
+        this.setService('import', a => new ImportService(a));
+        this.setService('list', a => new ListService(a));
+        this.setService('run', a => new RunService(a));
+        this.setService('version', a => new VersionService(a));
+        // Register core targets.
+        this.publishTargets.add(dockerPublishTarget);
+    }
     /** Which platform claims a directory - the first whose manifest provider recognizes it, because
      *  before a package is read there is nothing else to go on. `basePlatform` when none does, so the
      *  caller needs no guard. */
@@ -82,13 +106,6 @@ export class RmanApplication {
         }
         return this._repository;
     }
-    /** `info` until `--log-level` or `.rmanrc "logLevel"` is resolved - which cannot happen here,
-     *  since reading the config is itself work the application does. */
-    constructor(options) {
-        this.logger = new Logger(options?.logLevel ?? 'info');
-        registerCoreServices(this);
-        registerCoreTargets(this);
-    }
     /**
      * The single instance of a service, built on first use.
      *

package/core/{package.d.ts → classes/package.d.ts}

@@ -1,7 +1,7 @@
-import type { RmanApplication } from './application.js';
-import type { ResolvedConfig } from './config.js';
-import { Manifest } from './manifest.js';
-import type { Platform } from './plugin.js';
+import type { ResolvedConfig, RmanConfig } from '../../interfaces/rman-config.interface.js';
+import type { RmanApplication } from '../application.js';
+import { Manifest } from '../interfaces/manifest.js';
+import type { Platform } from '../interfaces/plugin.js';
 import type { Repository } from './repository.js';
 import { type VersionScheme } from './version-scheme.js';
 export declare class Package {
@@ -35,6 +35,14 @@ export declare class Package {
      * there is no second type to keep in step - see `Resolved`.
      */
     config: ResolvedConfig;
+    /**
+     * The same config **before** interpolation - every `${{ ... }}` and every value function still as
+     * the author wrote it.
+     *
+     * `Workspace` produces this when it cascades the directory chain; `Repository` evaluates it into
+     * {@link config}. Read `config` unless you specifically want the unevaluated text.
+     */
+    rawConfig: RmanConfig;
     /**
      * The repository this package belongs to - so anything holding a package can reach the whole
      * picture (its siblings, the root's config, git) without being handed it separately.

package/core/{package.js → classes/package.js}

@@ -1,5 +1,5 @@
 import path from 'path';
-import { Manifest } from './manifest.js';
+import { Manifest } from '../interfaces/manifest.js';
 import { semverScheme } from './version-scheme.js';
 export class Package {
     dirname;
@@ -32,6 +32,22 @@ export class Package {
      * there is no second type to keep in step - see `Resolved`.
      */
     config = {};
+    /**
+     * The same config **before** interpolation - every `${{ ... }}` and every value function still as
+     * the author wrote it.
+     *
+     * `Workspace` produces this when it cascades the directory chain; `Repository` evaluates it into
+     * {@link config}. Read `config` unless you specifically want the unevaluated text.
+     */
+    /* A second field rather than a stage of the first, because the two have different *types*:
+     * `config` is a `ResolvedConfig` by contract and is read in a hundred places, so putting a raw
+     * config there for the window between the cascade and the bake would make the type say something
+     * untrue everywhere.
+     *
+     * There was a `rawConfig` once before and it was removed as a duplicate - `version` kept one to
+     * re-read its own hooks, which `DEFERRED_PATHS` made unnecessary. This is not that: it is the
+     * handoff between two steps that genuinely produce different things. */
+    rawConfig = {};
     /**
      * The packages whose directories sit directly inside this one - **the tree edge**, in the order
      * the platform that claimed this directory gave them.

package/core/{repository.d.ts → classes/repository.d.ts}

@@ -1,9 +1,7 @@
-import type { RmanConfig } from '../interfaces/rman-config.interface.js';
-import { type DetectedBuiltin } from '../plugins/detect.js';
-import { RmanApplication } from './application.js';
-import { type ConfigScope, type GitScope, type PackageScope, type RepositoryScope } from './config.js';
+import { type ConfigScope, type GitScope, type PackageScope, type RepositoryScope } from '../../interfaces/config-scope.interface.js';
+import { RmanApplication } from '../application.js';
+import type { Platform } from '../interfaces/plugin.js';
 import { Package } from './package.js';
-import type { Platform } from './plugin.js';
 import { Workspace } from './workspace.js';
 export declare class Repository extends Package {
     readonly dirname: string;
@@ -14,8 +12,6 @@ export declare class Repository extends Package {
      *  really was. Used by `currentPackage` to scope commands to "the package I'm standing in". */
     readonly cwd: string;
     readonly rootPackage: Package;
-    /** See the `defineProperty` in the constructor - what detection supplied, when it did. */
-    readonly detectedBuiltin?: DetectedBuiltin;
     /** Commands the repository's plugins contributed, loaded during `create` because the workspace
      *  providers they bring are needed before any package can be found. `cli.ts` registers them. */
     /**
@@ -33,14 +29,15 @@ export declare class Repository extends Package {
      *  and because reading it is a subprocess: a deep walk of a package must not spawn one. */
     private _git?;
     /**
-     * Files `${{ read(...) }}` has parsed, shared by every package's scope and keyed by the identity
-     * of the bytes - see `readStructuredFile`.
+     * What `${{ file... }}` and `${{ read(...) }}` answer from, for every package.
      *
-     * **On the repository rather than per scope, and that is the whole point of it**: `configScope`
-     * is built once per package, so a cache living there would re-read a repository-level file once
-     * for every package that mentions it.
+     * **One per repository rather than one per scope, and that is the whole point of it**:
+     * `configScope` is built once per package, so a parse cache living there would re-read a
+     * repository-level file once for every package that mentions it. The cache inside is keyed by the
+     * identity of the bytes (`mtimeNs:size`), because rman writes JSON while it runs - `version`
+     * rewrites every bumped manifest and then re-interpolates its deferred hooks.
      */
-    private readonly _readCache;
+    private readonly _files;
     /**
      * The application this repository belongs to - its services, its technologies, its logger.
      *
@@ -139,24 +136,9 @@ export declare class Repository extends Package {
      */
     protected _linkPackages(tree: Workspace.Node, nodes: Workspace.Node[], packages: Package[]): void;
     /**
-     * Gives every package the selector a `"[glob]"` block and `--scope` match it by, and refuses two
-     * packages that would answer to the same one.
-     *
-     * **Its own step, before any config is resolved by a selector**, which is the ordering that makes
-     * the rest work: `_resolveConfigs` asks `resolveConfig` for each package *by selector*, so an
-     * address assigned afterwards would be applied to nothing.
-     *
-     * **`name` comes from the unmarked cascade only** - the same read `platform` gets, from the same
-     * cache, for the same reason. A `"[glob]"` block cannot set it (`assertSelectorBlocks` refuses
-     * one) because the glob matches the very thing the block would be setting.
-     *
-     * **Uniqueness is checked, and the cascade is the mistake it usually catches.** `name` cascades
-     * like every unmarked key, so one declaration above two packages gives both the same address -
-     * and the failure would otherwise be silent in the worst way: the config reaches both and
-     * `getPackage` returns whichever came first. The message names both directories, and says the
-     * cascade out loud when the two got it from one declaration.
+     * Bakes every package's config: the raw one the workspace cascaded, with every `${{ }}` and value
+     * function resolved against that package's scope.
      */
-    protected _assignSelectors(rootDir: string, cache: Map<string, RmanConfig>): Promise<void>;
     protected _resolveConfigs(): Promise<void>;
     protected _topoSortPackages(packages: Package[]): void;
     protected _packageScope(pkg: Package, targetVersion?: string): PackageScope;
@@ -196,18 +178,22 @@ export declare class Repository extends Package {
      * 3. **Ask the providers** for the layout. None recognizing it means a repository that is itself
      *    the one package.
      *
-     * **A repository whose `.rmanrc` names no plugin has no packages beyond itself**, and that is the
+     * **A repository no technology recognizes has no packages beyond itself**, and that is the
      * boundary working rather than failing: `workspaces` in a `package.json` is npm's idea, so it
-     * takes `plugins: ['node']` - or detection reading the directory as a Node one - for it to be
-     * read as a workspace at all.
+     * takes a platform that reads one for the directory to be a workspace at all. rman's own presets
+     * are laid under every root (see `DEFAULT_PRESETS`), so a plain Node repository needs no config
+     * file to say so; anything else arrives through `extends` or `platforms`.
      */
     static create(root?: string, options?: {
         deep?: number;
         app?: RmanApplication;
+        presets?: readonly string[];
     }): Promise<Repository>;
-    /** Finishes constructing `repo` with the async work a constructor can't do itself - resolving
-     *  `.rmanrc`/`.rmanrc.yml`/`.rmanrc.cjs`/`.mjs`/`.js` config (which may need a dynamic `import()`)
-     *  before the dependency graph is built from it. */
+    /**
+     * Takes the workspace's packages as this repository's own - the back-references a `Package` needs
+     * and the parent/child edges the walk established.
+     */
+    protected _adopt(workspace: Workspace): void;
     private static _init;
 }
 export declare namespace Repository {