rman 1.0.6 → 1.0.8

package/README.md

@@ -123,7 +123,8 @@ rman list --scope '@myorg/*' --ignore '*-internal'
 
 ### `rman info`
 
-Prints local environment (OS/CPU/memory, Node/npm/Yarn versions, git) and repository information.
+Prints local environment (OS/CPU/memory, Node + whichever package manager `.rmanrc
+"packageManager"` configures, git) and repository information.
 
 ```bash
 rman info

package/commands/changelog.command.js

@@ -29,6 +29,10 @@ export function initCli(repository, program) {
             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',
+        })
+            .option('include-skipped', {
+            describe: 'Also generate for a package with .rmanrc "publish.skip" - excluded by default',
+            type: 'boolean',
         }),
         handler: async (args) => {
             const from = args.from;
@@ -44,6 +48,7 @@ export function initCli(repository, program) {
                 from,
                 filePath: args.filePath,
                 root: args.root,
+                includeSkipped: args.includeSkipped,
             };
             const entries = args.write
                 ? await ChangelogService.generateToFile(repository, options)

package/commands/info.command.js

@@ -1,5 +1,6 @@
 import colors from 'ansi-colors';
 import semver from 'semver';
+import { CiService } from '../services/ci.service.js';
 import { SystemInfo } from '../services/system-info.js';
 function printSystemInfo(systemInfo) {
     const maxName = Object.keys(systemInfo).reduce((l, p) => Object.keys(systemInfo[p]).reduce((i, x) => Math.max(i, x.length), l), 0);
@@ -48,7 +49,7 @@ export function initCli(repository, program) {
             type: 'boolean',
         }),
         handler: async (args) => {
-            const systemInfo = await SystemInfo.getSystemInfo();
+            const systemInfo = await SystemInfo.getSystemInfo(CiService.resolvePackageManager(repository));
             const repositoryInfo = SystemInfo.getRepositoryInfo(repository);
             if (args.json) {
                 console.log(JSON.stringify({ ...systemInfo, repository: repositoryInfo }, undefined, 2));

package/constants.js

@@ -1 +1 @@
-export const version = '1.0.6';
+export const version = '1.0.8';

package/core/config.d.ts

@@ -63,6 +63,13 @@ export declare namespace RmanConfig {
          *  one that publishes both sets `['npm', 'docker']`. */
         target?: PublishTarget | PublishTarget[];
         docker?: DockerPublishOptions;
+        /** Excludes this package from `publish` entirely (npm and docker both), regardless of
+         *  `target`/`"private"` - a single, explicit "never published" statement, e.g. for a package
+         *  released through some separate, unrelated process. `changelog` also skips it by default
+         *  (see its own `--include-skipped`) - there's little point changelogging something that's
+         *  never actually released. Independent of `version`, which never consults this at all - a
+         *  package can still be meaningfully versioned without ever being published. */
+        skip?: boolean;
     }
     type PublishTarget = 'npm' | 'docker';
     /** Required once `"docker"` is one of this package's `publish.target`s - `publish --target

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rman",
   "description": "Repository manager",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

package/rmanrc.schema.json

@@ -120,6 +120,11 @@
         "docker": {
           "$ref": "#/definitions/dockerPublishConfig",
           "description": "Required once \"docker\" is one of this package's \"publish.target\"s."
+        },
+        "skip": {
+          "type": "boolean",
+          "default": false,
+          "description": "Excludes this package from \"publish\" entirely (npm and docker both), regardless of \"target\"/\"private\" - a single, explicit \"never published\" statement. \"changelog\" also skips it by default (see its own --include-skipped). Independent of \"version\", which never consults this."
         }
       }
     },

package/services/changelog.service.d.ts

@@ -28,6 +28,9 @@ export declare namespace ChangelogService {
          *  what's actually published) doesn't get changes silently skipped over - see
          *  `detectChangeHash`'s `catchUpFile`. */
         filePath?: string;
+        /** A package with `.rmanrc "publish.skip"` is excluded by default - little point changelogging
+         *  something that's never actually released. Set true to generate for it anyway. */
+        includeSkipped?: boolean;
     }
     /** One package's (root included) generated changelog entry - what `getEntries`/`generate`
      *  return. */

package/services/changelog.service.js

@@ -63,7 +63,7 @@ export var ChangelogService;
     async function getEntries(repository, options = {}, deps = {}) {
         const cwdScope = options.root ? undefined : repository.currentPackage;
         const packages = repository.getPackages().filter(p => p !== repository.rootPackage);
-        const targets = cwdScope ? [cwdScope] : filterPackages([repository.rootPackage, ...packages], options);
+        const targets = (cwdScope ? [cwdScope] : filterPackages([repository.rootPackage, ...packages], options)).filter(pkg => options.includeSkipped || !pkg.config.publish?.skip);
         const git = new GitHelper({ cwd: repository.dirname });
         // dropped up front, not just while grouping - a package whose only commits are version bumps
         // should get no entry at all, rather than a heading with nothing real underneath it.

package/services/docker-publish.service.js

@@ -22,7 +22,7 @@ export var DockerPublishService;
      */
     async function getPlan(repository, options = {}, deps = {}) {
         const git = new GitHelper({ cwd: repository.dirname });
-        const packages = filterPackages(repository.getPackages({ toposort: true }), options).filter(targetsDocker);
+        const packages = filterPackages(repository.getPackages({ toposort: true }), options).filter(pkg => targetsDocker(pkg) && !pkg.config.publish?.skip);
         const dirtyFiles = await git.listDirtyFiles({ absolute: true });
         const isDirty = (pkg) => dirtyFiles.some(f => !path.relative(pkg.dirname, f).startsWith('..'));
         const imageExists = deps.imageExists ?? defaultImageExists;

package/services/publish.service.js

@@ -41,7 +41,15 @@ export var PublishService;
         const entries = new Map();
         const toCheck = [];
         for (const pkg of packages) {
-            if (pkg.isPrivate) {
+            if (pkg.config.publish?.skip) {
+                entries.set(pkg.name, {
+                    package: pkg,
+                    version: pkg.version,
+                    status: 'skip',
+                    reason: 'excluded via .rmanrc "publish.skip"',
+                });
+            }
+            else if (pkg.isPrivate) {
                 entries.set(pkg.name, { package: pkg, version: pkg.version, status: 'skip', reason: 'private package' });
             }
             else if (isDirty(pkg)) {

package/services/system-info.d.ts

@@ -8,9 +8,15 @@ export declare namespace SystemInfo {
         root: string;
         packageCount: number;
     }
-    /** Whatever `envinfo` reports (OS/CPU/Memory/Shell, Node/Yarn/npm, git, installed
-     *  rman/typescript versions), grouped by category - shape is `envinfo`'s own, not ours. */
+    /** Whatever `envinfo` reports (OS/CPU/Memory/Shell, Node + the resolved package manager, git,
+     *  installed rman/typescript versions), grouped by category - shape is `envinfo`'s own, not ours. */
     type SystemInfo = Record<string, Record<string, unknown>>;
-    function getSystemInfo(options?: envinfo.RunConfig): Promise<SystemInfo.SystemInfo>;
+    /**
+     * `packageManager` (the repository's resolved `.rmanrc "packageManager"`, default `'npm'`)
+     * decides which package manager's version actually gets queried/reported - a pnpm-configured
+     * repo has no real use for npm's own version, since every package-manager-aware command
+     * (`ci`/`publish`) already shells out to pnpm, not npm, for it.
+     */
+    function getSystemInfo(packageManager?: 'npm' | 'yarn' | 'pnpm' | 'bun', options?: envinfo.RunConfig): Promise<SystemInfo.SystemInfo>;
     function getRepositoryInfo(repository: Repository): SystemInfo.RepositoryInfo;
 }

package/services/system-info.js

@@ -1,15 +1,34 @@
 import envinfo from 'envinfo';
 export var SystemInfo;
 (function (SystemInfo) {
-    async function getSystemInfo(options) {
+    /** `.rmanrc "packageManager"` value -> the `Binaries` key `envinfo` recognizes for it (`npm`/
+     *  `pnpm`/`bun` are lowercase, `Yarn` isn't - envinfo's own naming, not ours). */
+    const PACKAGE_MANAGER_BINARY = {
+        npm: 'npm',
+        yarn: 'Yarn',
+        pnpm: 'pnpm',
+        bun: 'bun',
+    };
+    /**
+     * `packageManager` (the repository's resolved `.rmanrc "packageManager"`, default `'npm'`)
+     * decides which package manager's version actually gets queried/reported - a pnpm-configured
+     * repo has no real use for npm's own version, since every package-manager-aware command
+     * (`ci`/`publish`) already shells out to pnpm, not npm, for it.
+     */
+    async function getSystemInfo(packageManager, options) {
         return JSON.parse(await envinfo.run({
             System: ['OS', 'CPU', 'Memory', 'Shell'],
-            Binaries: ['Node', 'Yarn', 'npm'],
+            Binaries: ['Node', PACKAGE_MANAGER_BINARY[packageManager ?? 'npm']],
             Utilities: ['Git'],
             npmPackages: ['rman', 'typescript'],
             npmGlobalPackages: ['typescript'],
             ...options,
-        }, { json: true }));
+        }, 
+        // showNotFound: without it, envinfo *omits* a configured-but-uninstalled package manager
+        // from Binaries entirely (indistinguishable from never having asked) instead of reporting
+        // "Not Found" - worth surfacing, since it means .rmanrc "packageManager" points at
+        // something that isn't actually on this machine.
+        { json: true, showNotFound: true }));
     }
     SystemInfo.getSystemInfo = getSystemInfo;
     function getRepositoryInfo(repository) {

package/services/version.service.js

@@ -172,6 +172,10 @@ export var VersionService;
                     scope: entry.package.name,
                     root: true,
                     from,
+                    // version doesn't consult "publish.skip" at all (a package can still be meaningfully
+                    // versioned/changelogged without ever being published) - this entry was already decided
+                    // to bump, so its folded-in changelog shouldn't then be silently dropped by that flag.
+                    includeSkipped: true,
                 });
                 for (const ce of changelogEntries) {
                     changelogFileByPackage.set(ce.package.name, path.relative(repository.dirname, path.join(ce.package.dirname, ce.filePath)));

package/utils/change-hash.d.ts

@@ -43,13 +43,17 @@ export interface DetectChangeHashOptions {
  * Resolves the commit/hash a package's changes should be measured "since" - the boundary
  * `changelog --from` uses, but reusable anywhere a command wants to answer "what changed for this
  * package". An explicit `options.from` (anything but `"npm"`) is returned as-is, applying the same
- * way to every package. Otherwise, it's auto-detected from the package's currently-published npm
- * version: looked up via `npmViewVersion`, then mapped to a git tag using `.rmanrc
- * changelog.tagPattern` (so independent and fixed monorepo versioning schemes both work - see
- * `tagPattern`) - and, if `catchUpFile` is given and exists, widened to also cover anything that
- * file hasn't caught up on yet (see its doc comment). Returns `undefined` when nothing can be
- * resolved at all (unpublished, no network, no matching tag, no catch-up file) - callers should
- * fall back to their own default in that case (e.g. `GitHelper.listCommits`'s "not yet pushed"
- * default when no hash is given).
+ * way to every package. Otherwise, it's auto-detected in order: (1) the package's
+ * currently-published npm version - looked up via `npmViewVersion`, then mapped to a git tag using
+ * `.rmanrc changelog.tagPattern` (so independent and fixed monorepo versioning schemes both work -
+ * see `tagPattern`); (2) failing that (never published, private, no network, ...), this package's
+ * own most recent release tag directly - the same `findLatestTag` lookup `version` itself uses, so
+ * a package that's never been on npm (e.g. Docker-only) but has real tags from a previous `version`
+ * run still gets a correct boundary, not just "everything ever". Either way, if `catchUpFile` is
+ * given and exists, the result is widened to also cover anything that file hasn't caught up on yet
+ * (see its doc comment). Returns `undefined` when nothing can be resolved at all (never published
+ * *and* never tagged, no catch-up file - a genuinely first-ever release) - callers should fall back
+ * to their own default in that case (e.g. `GitHelper.listCommits`'s "not yet pushed" default when
+ * no hash is given).
  */
 export declare function detectChangeHash(git: GitHelper, pkg: Package, options?: DetectChangeHashOptions): Promise<string | undefined>;

package/utils/change-hash.js

@@ -47,14 +47,18 @@ export async function defaultNpmViewVersion(name, cwd) {
  * Resolves the commit/hash a package's changes should be measured "since" - the boundary
  * `changelog --from` uses, but reusable anywhere a command wants to answer "what changed for this
  * package". An explicit `options.from` (anything but `"npm"`) is returned as-is, applying the same
- * way to every package. Otherwise, it's auto-detected from the package's currently-published npm
- * version: looked up via `npmViewVersion`, then mapped to a git tag using `.rmanrc
- * changelog.tagPattern` (so independent and fixed monorepo versioning schemes both work - see
- * `tagPattern`) - and, if `catchUpFile` is given and exists, widened to also cover anything that
- * file hasn't caught up on yet (see its doc comment). Returns `undefined` when nothing can be
- * resolved at all (unpublished, no network, no matching tag, no catch-up file) - callers should
- * fall back to their own default in that case (e.g. `GitHelper.listCommits`'s "not yet pushed"
- * default when no hash is given).
+ * way to every package. Otherwise, it's auto-detected in order: (1) the package's
+ * currently-published npm version - looked up via `npmViewVersion`, then mapped to a git tag using
+ * `.rmanrc changelog.tagPattern` (so independent and fixed monorepo versioning schemes both work -
+ * see `tagPattern`); (2) failing that (never published, private, no network, ...), this package's
+ * own most recent release tag directly - the same `findLatestTag` lookup `version` itself uses, so
+ * a package that's never been on npm (e.g. Docker-only) but has real tags from a previous `version`
+ * run still gets a correct boundary, not just "everything ever". Either way, if `catchUpFile` is
+ * given and exists, the result is widened to also cover anything that file hasn't caught up on yet
+ * (see its doc comment). Returns `undefined` when nothing can be resolved at all (never published
+ * *and* never tagged, no catch-up file - a genuinely first-ever release) - callers should fall back
+ * to their own default in that case (e.g. `GitHelper.listCommits`'s "not yet pushed" default when
+ * no hash is given).
  */
 export async function detectChangeHash(git, pkg, options = {}) {
     if (options.from && options.from !== 'npm')
@@ -69,6 +73,8 @@ export async function detectChangeHash(git, pkg, options = {}) {
         const tag = starIdx === -1 ? expanded : expanded.slice(0, starIdx) + publishedVersion + expanded.slice(starIdx + 1);
         npmHash = (await git.tagExists(tag)) ? tag : undefined;
     }
+    if (!npmHash)
+        npmHash = await findLatestTag(git, pkg);
     const fileHash = options.catchUpFile ? await git.lastCommitTouching(options.catchUpFile) : undefined;
     if (!fileHash)
         return npmHash;