rman 2.0.0-beta.2 → 2.0.0-beta.4

package/utils/git.js

@@ -148,6 +148,32 @@ export class GitHelper {
         }
     }
     /** Whether `tag` exists as an exact git tag name (not a glob - a literal ref check). */
+    /**
+     * Every tag matching `pattern`, paired with the **commit** it points at - newest version first,
+     * the same order `listTags` returns.
+     *
+     * `%(*objectname)` is the dereferenced target and is empty for a lightweight tag, so the commit
+     * is that or `%(objectname)`. rman's own tags are lightweight; a repository's existing ones may
+     * not be, and an annotated tag's `objectname` is the *tag object*, which matches no commit and
+     * would make the tag silently invisible to anything comparing shas.
+     */
+    async listTagCommits(pattern) {
+        try {
+            const { stdout } = await execFileAsync('git', ['tag', '--list', pattern, '--sort=-v:refname', '--format=%(refname:short)%09%(objectname)%09%(*objectname)'], { cwd: this.cwd });
+            return stdout
+                .trim()
+                .split(/\r?\n/)
+                .filter(Boolean)
+                .map(line => {
+                const [tag, objectname, deref] = line.split('\t');
+                return { tag, sha: deref || objectname };
+            })
+                .filter(t => t.tag && t.sha);
+        }
+        catch {
+            return [];
+        }
+    }
     async tagExists(tag) {
         try {
             await execFileAsync('git', ['rev-parse', '--verify', '--quiet', `refs/tags/${tag}`], { cwd: this.cwd });
@@ -197,6 +223,45 @@ export class GitHelper {
     /** The repository's very first commit (the oldest root commit, for a history with several) -
      *  `undefined` for a repository with no commits at all. The "since the beginning" boundary for
      *  a package being released for the first time, with no earlier tag to measure from. */
+    /** HEAD's own sha, or `undefined` in a repository with no commits yet (or none at all) - the
+     *  same "answer nothing rather than throw" shape `rootCommit` and `describeTag` take, because
+     *  every caller here already has a "nothing to go on" branch. */
+    /** The date a ref points at, as `YYYY-MM-DD`. The **committer** date, not the author's: a
+     *  rebased or cherry-picked release commit was authored earlier than it shipped, and what a
+     *  changelog heading states is when the release happened. `undefined` for a ref that resolves to
+     *  nothing. */
+    async commitDate(ref) {
+        try {
+            const { stdout } = await execFileAsync('git', ['log', '-1', '--format=%cI', ref], { cwd: this.cwd });
+            return stdout.trim().slice(0, 10) || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** The commit `ref` names - a sha, a tag, a branch - or `undefined` when git does not recognize
+     *  it. `^{commit}` so an annotated tag answers with the commit rather than the tag object, and
+     *  so a tree or blob answers with nothing rather than a sha that matches no commit. */
+    async resolveCommit(ref) {
+        try {
+            const { stdout } = await execFileAsync('git', ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`], {
+                cwd: this.cwd,
+            });
+            return stdout.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async headSha() {
+        try {
+            const { stdout } = await execFileAsync('git', ['rev-parse', 'HEAD'], { cwd: this.cwd });
+            return stdout.trim() || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
     async rootCommit() {
         try {
             const { stdout } = await execFileAsync('git', ['rev-list', '--max-parents=0', 'HEAD'], { cwd: this.cwd });

package/utils/logger.d.ts

@@ -1,4 +1,4 @@
-import type { Repository } from '../core/repository.js';
+import type { Repository } from '../core/classes/repository.js';
 export type LogLevel = 'silent' | 'error' | 'info' | 'verbose';
 export declare const LOG_LEVELS: LogLevel[];
 /**

package/utils/package-filter.d.ts

@@ -1,11 +1,18 @@
 import type { Argv } from 'yargs';
-import type { Package } from '../core/package.js';
+import type { Package } from '../core/classes/package.js';
 /** Shared by every command that iterates packages (`run`/`build`/`test`/`exec`, `list`, `ci`,
  *  `clean`, `version`, `publish`, `changelog`) - narrows *which* packages a command applies to,
  *  independent of what the command actually does to them. The repository's own standing filter,
  *  `.rmanrc "skip"`, is applied by `filterPackages` itself rather than being an option here: it is
  *  the repository's statement, not the caller's. */
 export interface PackageFilterOptions {
+    /**
+     * The technologies the **command itself** is for - `clean` and `ci` are npm's alone. Absent means
+     * every platform, which is what a command that speaks for no one in particular says.
+     *
+     * Declared as `CommandMetadata.platforms` and carried here; a repository never writes it.
+     */
+    commandPlatforms?: string[];
     /** Only include packages whose name matches at least one of these globs (e.g. `@scope/*`), or
      *  **`"/"`** for the repository's own root package - see `ROOT_SELECTOR`. */
     scope?: string | string[];

package/utils/package-filter.js

@@ -131,6 +131,7 @@ export function readPackageFilterOptions(args) {
         scope: args.scope,
         ignore: args.ignore,
         platform: args.platform,
+        commandPlatforms: args.commandPlatforms,
         deps: args.deps,
         dependents: args.dependents,
     };
@@ -169,6 +170,12 @@ applySkip = true) {
         const selects = selector(options.ignore);
         matched = matched.filter(p => !selects(p));
     }
+    /** The command's own technologies, before the user's `--platform`: a declaration is the hard
+     *  limit and the flag narrows inside it. Silent where `--platform` is loud - see the field. */
+    if (options.commandPlatforms?.length) {
+        const wanted = new Set(options.commandPlatforms.map(n => n.toLowerCase()));
+        matched = matched.filter(p => wanted.has(p.provider.toLowerCase()));
+    }
     if (options.platform !== undefined) {
         const wanted = platformNames(options.platform, packages);
         matched = matched.filter(p => wanted.has(p.provider.toLowerCase()));

package/utils/printable-config.d.ts

@@ -13,3 +13,11 @@
  * reads as `[Function]`, which is itself worth seeing.
  */
 export declare function printableConfig<T>(config: T): T;
+/**
+ * A resolved config with the **contribution keys** dropped - `plugins`, `platforms`, `commands`,
+ * `publishTargets` - for `rman config` and `--config`, which exist to show what a repository is
+ * *configured* to do.
+ *
+ * Returns a copy; the config itself is what every command reads and is never touched.
+ */
+export declare function withoutContributions<T extends object>(config: T): T;

package/utils/printable-config.js

@@ -1,3 +1,4 @@
+import { CODE_SUBTREES } from '../core/config/config-paths.js';
 /**
  * A copy of a resolved config with every value a serializer cannot represent replaced by a short
  * description of it - for `rman config` and `--config`, which exist to be *looked at*.
@@ -15,6 +16,50 @@
 export function printableConfig(config) {
     return walk(config, new WeakSet());
 }
+/**
+ * A resolved config with the **contribution keys** dropped - `plugins`, `platforms`, `commands`,
+ * `publishTargets` - for `rman config` and `--config`, which exist to show what a repository is
+ * *configured* to do.
+ *
+ * Returns a copy; the config itself is what every command reads and is never touched.
+ */
+/* **Those four are code, not settings** (`CODE_SUBTREES`), and printing them answers a question
+ * nobody asked: a platform dumps its manifest provider and version planner, a publish target its
+ * whole option table, and `commands` comes out as a list of `[Function]` - which is the clearest
+ * evidence of all that they do not belong in this output. Measured on this repository, where
+ * `rman config` printed forty lines of the npm target's flags above the two keys its `.rmanrc`
+ * actually sets.
+ *
+ * **And silently, which was argued the other way first.** The note that announced them read as the
+ * sibling of the `version.<slot>` one, and it is not: that note explains a *visible* oddity - an
+ * unresolved `${{ }}` sitting among resolved values, which without it reads as interpolation being
+ * broken - while this one announced an absence the reader was not looking for. The measurement that
+ * settled it: presets go under every root, so every config carries all four and the note was
+ * printed **every time**, which makes it a banner rather than a report. At this repository's root
+ * it was one of three lines. A reader asking which technologies are loaded is asking `rman info`,
+ * and one asking whether their command registered is asking `rman --help`.
+ *
+ * **`CODE_SUBTREES` itself, not a second copy of those four names.** `config-paths.ts` imports
+ * nothing, so there is no cycle to buy by reaching for it - and a printer quietly keeping its own
+ * list is how a key added to one side stops being dropped by the other. That exact shape was live
+ * in this tree an hour earlier: `presetNames()` held a hardcoded `['node']` beside a resolver that
+ * looked somewhere else, and the error message named the preset it had just failed to find.
+ *
+ * **Top level only, matching the runtime rule** (`ConfigInterpolator._isCodePath` checks
+ * `segments[0]`). `Resolved` skips these names at *every* level because the selector index
+ * re-enters the config, and the two have disagreed since - this is not the place to pick a side,
+ * and stripping them deeper would hide a script that happens to be called `commands`. By the time
+ * either printer runs the selector blocks are merged in anyway, so there is no deeper one to find.
+ *
+ * **Distinct from `printableConfig`, which makes a value serializable rather than deciding what is
+ * worth showing.** A step written as a function still prints as `[Function: copyDocs]` - that one
+ * *is* a setting. */
+export function withoutContributions(config) {
+    const result = { ...config };
+    for (const key of CODE_SUBTREES)
+        delete result[key];
+    return result;
+}
 function walk(value, seen) {
     if (typeof value === 'function')
         return `[Function${value.name ? `: ${value.name}` : ''}]`;

package/utils/progress-panel.d.ts

@@ -6,6 +6,15 @@ export interface ProgressItem {
     /** Label of the step currently running, for work with more than one step (e.g. `run`'s
      *  npm-script steps) - omit `stepsTotal` entirely for single-step work like a plain command. */
     currentStep?: string;
+    /**
+     * **What the current step actually runs** - the shell command, or a function step's name - shown
+     * beside the label so a silent step says what it is.
+     *
+     * The label alone answers "which slot", which is what a reader already knows; a step sitting at
+     * `before (2/9)` for ten seconds with nothing on stdout is the case this exists for, and it is
+     * the common one for a build.
+     */
+    currentCommand?: string;
     stepIndex?: number;
     stepsTotal?: number;
     /** Last captured output line, shown dimmed under the item while it's running. */

package/utils/progress-panel.js

@@ -76,7 +76,15 @@ export class ProgressPanel {
             const step = item.stepsTotal && item.stepsTotal > 1 && item.stepIndex != null
                 ? `${item.currentStep} (${item.stepIndex + 1}/${item.stepsTotal})`
                 : item.currentStep || '';
-            const group = [`${spinner} ${colors.bold(item.name)}  ${colors.gray(step)}  ${colors.yellow(elapsed)}`];
+            /** Measured against the *plain* text: every piece below is wrapped in escape sequences, and
+             *  `String.length` counts those, so budgeting on the rendered string wraps a row that fits. */
+            const fixed = `  ${item.name}  ${step}  ${elapsed}`.length;
+            const command = truncate(item.currentCommand ?? '', (process.stdout.columns || 80) - fixed - 2);
+            const group = [
+                `${spinner} ${colors.bold(item.name)}  ${colors.gray(step)}` +
+                    (command ? `  ${colors.cyan(command)}` : '') +
+                    `  ${colors.yellow(elapsed)}`,
+            ];
             if (item.lastLine)
                 group.push(`    ${colors.dim(item.lastLine)}`);
             if (used + group.length > budget)
@@ -141,6 +149,20 @@ export class ProgressPanel {
         return { successCount, failedCount, skippedCount };
     }
 }
+/**
+ * `text` cut to `width`, with a `…` in place of what was dropped.
+ *
+ * **Cut from the end, not the middle.** A command's information is front-loaded - `tsc -b
+ * packages/rman/tsconfig.json` says what it is in the first four characters, and a middle-ellipsis
+ * spends them on a tail nobody is reading at a glance. The one thing it must never do is wrap: a
+ * block taller than the terminal breaks the panel's cursor-up arithmetic, which is the same reason
+ * the row budget above exists.
+ */
+function truncate(text, width) {
+    if (!text || width <= 1)
+        return '';
+    return text.length <= width ? text : `${text.slice(0, width - 1)}…`;
+}
 /** Classic braille "dots" spinner (cli-spinners' default), one frame per render tick. */
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 function renderProgressBar(done, total, width = 24) {

package/utils/release-version.d.ts

@@ -1,4 +1,4 @@
-import type { Package } from '../core/package.js';
+import type { Package } from '../core/classes/package.js';
 import type { GitHelper } from './git.js';
 /**
  * A calendar release version: `YYYY.M.D-HHmm`, every part **unpadded** (`2026.9.5-930`, not

package/utils/run-options.js

@@ -53,7 +53,7 @@ export const runOptions = {
     changed: {
         target: 'cli',
         alias: 'c',
-        describe: 'Only run in packages that have changed since the last publish',
+        describe: 'Only run in packages you have touched but not pushed - uncommitted, or committed and not yet on the upstream branch. Not a release question; see "version --json" for that',
         type: 'boolean',
     },
     changedSince: {

package/utils/version-group.d.ts

@@ -0,0 +1,31 @@
+import type { Package } from '../core/classes/package.js';
+/**
+ * The identity packages are batched by when `version` plans a release - `.rmanrc group`, cascaded
+ * like every unmarked key. `true` (the default) puts a package in the implicit repo-wide group, a
+ * non-empty string joins exactly the packages naming the same one, and `false` makes it a group of
+ * itself.
+ *
+ * **It lives here rather than on the planner because two unrelated things need the same answer.**
+ * `VersionPlanService.resolveGroupKey` batches the plan with it; `ChangeHashService.tagPattern`
+ * asks how many lines the repository releases along, which decides whether a repo-wide tag can
+ * name a release at all. Two copies of five lines would be easy to write and impossible to keep in
+ * step, and the failure they would produce is silent - a boundary computed under one answer and a
+ * tag written under the other.
+ *
+ * `resolveGroupKey` stays `protected` and delegates here, so a planner can still override the
+ * batching; what it cannot do is leave the tag pattern behind, which is the point.
+ */
+export declare function groupKeyOf(pkg: Package): string;
+/**
+ * How many distinct version lines this package's repository releases along - 1 when every package
+ * moves together, more once anything is grouped apart.
+ *
+ * **Structural, exactly like `usesCalendarVersion`'s group count**, and for the same reason: two
+ * lines can hold the same number today and diverge tomorrow, so reading the versions would move
+ * the answer under the repository's feet.
+ *
+ * `1` for a package belonging to no repository yet - a bare `new Package(dir, app)`, which the test
+ * fixtures build. One line is the answer that changes nothing, which is what an unknown should
+ * resolve to here.
+ */
+export declare function versionLineCount(pkg: Package): number;

package/utils/version-group.js

@@ -0,0 +1,43 @@
+/**
+ * The identity packages are batched by when `version` plans a release - `.rmanrc group`, cascaded
+ * like every unmarked key. `true` (the default) puts a package in the implicit repo-wide group, a
+ * non-empty string joins exactly the packages naming the same one, and `false` makes it a group of
+ * itself.
+ *
+ * **It lives here rather than on the planner because two unrelated things need the same answer.**
+ * `VersionPlanService.resolveGroupKey` batches the plan with it; `ChangeHashService.tagPattern`
+ * asks how many lines the repository releases along, which decides whether a repo-wide tag can
+ * name a release at all. Two copies of five lines would be easy to write and impossible to keep in
+ * step, and the failure they would produce is silent - a boundary computed under one answer and a
+ * tag written under the other.
+ *
+ * `resolveGroupKey` stays `protected` and delegates here, so a planner can still override the
+ * batching; what it cannot do is leave the tag pattern behind, which is the point.
+ */
+export function groupKeyOf(pkg) {
+    const g = pkg.config?.group;
+    if (g === false)
+        return `solo:${pkg.name}`;
+    if (typeof g === 'string' && g)
+        return `named:${g}`;
+    return 'default';
+}
+/**
+ * How many distinct version lines this package's repository releases along - 1 when every package
+ * moves together, more once anything is grouped apart.
+ *
+ * **Structural, exactly like `usesCalendarVersion`'s group count**, and for the same reason: two
+ * lines can hold the same number today and diverge tomorrow, so reading the versions would move
+ * the answer under the repository's feet.
+ *
+ * `1` for a package belonging to no repository yet - a bare `new Package(dir, app)`, which the test
+ * fixtures build. One line is the answer that changes nothing, which is what an unknown should
+ * resolve to here.
+ */
+export function versionLineCount(pkg) {
+    const repository = pkg.repository;
+    const packages = repository?.packages;
+    if (!packages?.length)
+        return 1;
+    return new Set(packages.map(groupKeyOf)).size;
+}

package/commands/changed.command.d.ts

@@ -1,80 +0,0 @@
-import { type RmanConfig } from '../interfaces/rman-config.interface.js';
-declare const COMMAND: "changed";
-declare const config: {
-    json: {
-        target: "cli";
-        alias: string;
-        describe: string;
-        type: "boolean";
-    };
-    scope: {
-        target: "cli";
-        describe: string;
-        type: "string";
-    };
-    ignore: {
-        target: "cli";
-        describe: string;
-        type: "string";
-    };
-    platform: {
-        target: "cli";
-        describe: string;
-        type: "string";
-    };
-    deps: {
-        target: "cli";
-        describe: string;
-        type: "boolean";
-    };
-    dependents: {
-        target: "cli";
-        describe: string;
-        type: "boolean";
-    };
-};
-type Args = RmanConfig.ArgsOf<typeof config, typeof COMMAND>;
-/** Declares no `target: 'config'` option, so it contributes nothing to `RmanConfig` and writes no
- *  augmentation - a command that owns no config key simply has none. */
-declare const changedCommand: (app: import("../index.js").RmanApplication) => {
-    command: "changed";
-    describe: string;
-    config: {
-        json: {
-            target: "cli";
-            alias: string;
-            describe: string;
-            type: "boolean";
-        };
-        scope: {
-            target: "cli";
-            describe: string;
-            type: "string";
-        };
-        ignore: {
-            target: "cli";
-            describe: string;
-            type: "string";
-        };
-        platform: {
-            target: "cli";
-            describe: string;
-            type: "string";
-        };
-        deps: {
-            target: "cli";
-            describe: string;
-            type: "boolean";
-        };
-        dependents: {
-            target: "cli";
-            describe: string;
-            type: "boolean";
-        };
-    };
-    examples: {
-        command: string;
-    }[];
-    handler: (args: Args) => Promise<void>;
-};
-export default changedCommand;

package/commands/changed.command.js

@@ -1,36 +0,0 @@
-import colors from 'ansi-colors';
-import { registerCommand } from '../interfaces/rman-config.interface.js';
-import { VersionPlanService } from '../services/version-plan.service.js';
-import { packageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
-const COMMAND = 'changed';
-const config = {
-    ...packageFilterOptions,
-    json: { target: 'cli', alias: 'j', describe: 'Print output as JSON', type: 'boolean' },
-};
-/** Declares no `target: 'config'` option, so it contributes nothing to `RmanConfig` and writes no
- *  augmentation - a command that owns no config key simply has none. */
-const changedCommand = registerCommand(app => {
-    const repository = app.repository;
-    return {
-        command: COMMAND,
-        describe: 'Shows which packages the next "version" run would bump, without changing anything',
-        config,
-        examples: [{ command: '$0 changed' }, { command: '$0 changed --json' }],
-        handler: async (args) => {
-            const plan = await VersionPlanService.getPlanner(app).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));
-            }
-        },
-    };
-});
-export default changedCommand;