rman 1.0.9 → 1.0.10

package/README.md

@@ -265,11 +265,10 @@ algorithm, prerelease semantics, and `"workspace:"` dependency-range handling.
 
 ### `rman publish`
 
-Publishes every package to its configured target(s) - `npm` by default, or whatever each package's
-own `.rmanrc "publish.target"` says (`"npm"`, `"docker"`, `"github"`, or any combination). Each
-target decides for itself whether the current version is already out there: `npm view` on the npm
-side, `docker manifest inspect` on the docker side, and the GitHub Release for that version's own
-tag on the github side.
+Publishes every package to its configured registry - `npm` by default, or whatever each package's
+own `.rmanrc "publish.target"` says (`"npm"`, `"docker"`, or both). Each target decides for itself
+whether the current version is already out there: `npm view` on the npm side, `docker manifest
+inspect` on the docker side.
 
 ```bash
 rman publish                              # show the plan, then ask for confirmation
@@ -281,7 +280,6 @@ rman publish --otp 123456
 rman publish --registry https://registry.example.com --userconfig ./ci.npmrc
 rman publish --package-manager pnpm
 rman publish --target docker              # only the packages configured for the "docker" target
-rman publish --target github              # only the GitHub Release side of it
 ```
 
 A `"workspace:*"`/`"workspace:^"`/`"workspace:~"` dependency range is automatically rewritten to a
@@ -292,10 +290,19 @@ A package opts into building/pushing a Docker image via `.rmanrc "publish.target
 a `"publish.docker"` block (`image`, `platforms`, `buildContexts`, `buildArgs`, ...) - see
 [docs/cli/publish.md#docker-publishing-publishdocker](docs/cli/publish.md#docker-publishing-publishdocker).
 
-A package with no package registry of its own - a standalone app shipped as release assets, or one
-deployed elsewhere with the release just recording that it shipped - opts into
-`"publish.target": ["github"]` instead, optionally with `"publish.github": { "assets": [...] }` -
-see [docs/cli/publish.md#github-releases-publishgithub](docs/cli/publish.md#github-releases-publishgithub).
+### `rman github-release`
+
+Creates the repository's GitHub Release for the version that just shipped - one per run, named after
+the repository's own release tag, with notes covering every package that shipped under it.
+
+```bash
+rman github-release --yes
+```
+
+It is deliberately neither a `publish.target` nor opt-in: a release isn't a registry a package ships
+to, it's the repository's own record that a version shipped, and every repository wants that record.
+It needs no configuration at all - see
+[docs/cli/github-release.md](docs/cli/github-release.md).
 
 ### `rman import <path>`
 

package/cli.js

@@ -11,6 +11,7 @@ import * as ciCommand from './commands/ci.command.js';
 import * as cleanCommand from './commands/clean.command.js';
 import * as diffCommand from './commands/diff.command.js';
 import * as execCommand from './commands/exec.command.js';
+import * as githubReleaseCommand from './commands/github-release.command.js';
 import * as importCommand from './commands/import.command.js';
 import * as infoCommand from './commands/info.command.js';
 import * as listCommand from './commands/list.command.js';
@@ -61,6 +62,7 @@ export async function runCli(options) {
         testCommand.initCli(repository, program);
         versionCommand.initCli(repository, program);
         publishCommand.initCli(repository, program);
+        githubReleaseCommand.initCli(repository, program);
         execCommand.initCli(repository, program);
         changedCommand.initCli(repository, program);
         diffCommand.initCli(repository, program);

package/commands/github-release.command.d.ts

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

package/commands/github-release.command.js

@@ -0,0 +1,119 @@
+import readline from 'node:readline/promises';
+import colors from 'ansi-colors';
+import { GithubReleaseService } from '../services/github-release.service.js';
+import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
+export function initCli(repository, program) {
+    program.command({
+        command: 'github-release',
+        describe: "Creates the repository's GitHub Release for the version that just shipped",
+        builder: cmd => applyBranchGuardOptions(cmd)
+            .example('$0 github-release', '# Show what would be released, then ask for confirmation')
+            .example('$0 github-release --yes', '# Create it immediately, no confirmation (CI)')
+            .example('$0 github-release --dry-run', '# Only show the plan')
+            .option('yes', {
+            alias: 'y',
+            describe: 'Skip the confirmation prompt and create the release immediately',
+            type: 'boolean',
+        })
+            .option('dry-run', {
+            describe: 'Only show the plan - never creates anything, regardless of --yes',
+            type: 'boolean',
+        })
+            .option('json', {
+            alias: 'j',
+            describe: 'Print the plan as JSON instead of text',
+            type: 'boolean',
+        })
+            .option('repository', {
+            describe: 'The "owner/repo" the release is created in - default: .rmanrc "githubRelease.repository", ' +
+                'falling back to the "origin" remote.',
+            type: 'string',
+        })
+            .option('ignore-dirty', {
+            describe: 'Release anyway when the working tree has uncommitted changes, instead of aborting',
+            type: 'boolean',
+        }),
+        handler: async (args) => {
+            await assertAllowedBranch(repository, readBranchGuardOptions(args));
+            // No package filtering: a release belongs to the repository, not to a package, so there is
+            // nothing for --scope/--ignore to narrow down.
+            const plan = await GithubReleaseService.getPlan(repository, {
+                ignoreDirty: args.ignoreDirty,
+                repository: args.repository,
+            });
+            if (args.json) {
+                console.log(JSON.stringify(plan.map(e => ({
+                    tag: e.tag,
+                    repository: e.repository,
+                    status: e.status,
+                    version: e.version,
+                    reason: e.reason,
+                })), undefined, 2));
+            }
+            else {
+                for (const e of plan) {
+                    const name = colors.cyan(e.tag ?? e.version);
+                    switch (e.status) {
+                        case 'publish':
+                            console.log(colors.green('release'), name, colors.gray(`${e.repository} - ${e.reason ?? ''}`));
+                            break;
+                        case 'up-to-date':
+                            console.log(colors.gray('up-to-date'), name, colors.gray(e.reason ?? ''));
+                            break;
+                        case 'skip':
+                            console.log(colors.cyan('skip'), name, colors.gray(e.reason ?? ''));
+                            break;
+                        case 'error':
+                            console.log(colors.red('error'), name, colors.red(e.reason ?? ''));
+                            break;
+                    }
+                }
+            }
+            const error = plan.find(e => e.status === 'error');
+            if (error) {
+                const err = new Error(error.reason ?? 'Unable to prepare the GitHub Release');
+                err.logged = true;
+                throw err;
+            }
+            if (!plan.some(e => e.status === 'publish')) {
+                if (!args.json)
+                    console.log(colors.gray('Nothing to release.'));
+                return;
+            }
+            if (args.dryRun)
+                return;
+            let proceed = !!args.yes;
+            if (!proceed) {
+                if (!process.stdout.isTTY) {
+                    console.log(colors.gray('Not a TTY - refusing to prompt. Pass --yes to release non-interactively.'));
+                    return;
+                }
+                proceed = await confirm('Create this release?');
+            }
+            if (!proceed)
+                return;
+            const applied = await GithubReleaseService.applyPlan(repository, plan);
+            const failed = applied.find(e => e.status === 'error');
+            if (failed) {
+                console.log(colors.red('failed'), colors.cyan(failed.tag ?? ''), colors.red(failed.reason ?? ''));
+                const err = new Error('"github-release" failed');
+                err.logged = true;
+                throw err;
+            }
+            for (const e of applied) {
+                if (e.status === 'publish')
+                    console.log(colors.green('released'), colors.cyan(e.tag ?? ''));
+            }
+        },
+    });
+}
+async function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = await rl.question(`${question} (y/N) `);
+        return /^y(es)?$/i.test(answer.trim());
+    }
+    finally {
+        rl.close();
+    }
+}

package/commands/publish.command.js

@@ -2,7 +2,6 @@ import readline from 'node:readline/promises';
 import colors from 'ansi-colors';
 import { CiService } from '../services/ci.service.js';
 import { DockerPublishService } from '../services/docker-publish.service.js';
-import { GithubReleaseService } from '../services/github-release.service.js';
 import { PublishService } from '../services/publish.service.js';
 import { applyBranchGuardOptions, assertAllowedBranch, readBranchGuardOptions } from '../utils/branch-guard.js';
 import { applyPackageFilterOptions, readPackageFilterOptions } from '../utils/package-filter.js';
@@ -15,7 +14,6 @@ export function initCli(repository, program) {
             .example('$0 publish --yes', '# Publish immediately, no confirmation')
             .example('$0 publish --dry-run', '# Only show the plan, never publish')
             .example('$0 publish --target docker', '# Only the packages configured for the "docker" target')
-            .example('$0 publish --target github', '# Only the GitHub Release side of it')
             .option('yes', {
             alias: 'y',
             describe: 'Skip the confirmation prompt and publish immediately',
@@ -32,12 +30,12 @@ export function initCli(repository, program) {
             type: 'boolean',
         })
             .option('target', {
-            describe: 'Restrict this run to just these publish target(s) ("npm"/"docker"/"github", repeatable) - default: ' +
+            describe: 'Restrict this run to just these publish target(s) ("npm"/"docker", repeatable) - default: ' +
                 'every target each package itself is configured for (.rmanrc "publish.target", "npm" when unset). ' +
                 'A package that opts into "docker" but has no "publish.docker" config errors clearly instead of ' +
                 'being silently skipped.',
             type: 'array',
-            choices: ['npm', 'docker', 'github'],
+            choices: ['npm', 'docker'],
         })
             .option('ignore-dirty', {
             describe: 'Exclude a package with uncommitted local changes instead of aborting the whole run',
@@ -76,18 +74,12 @@ export function initCli(repository, program) {
             describe: 'Prefixed onto a bare (no "/") "publish.docker.image" - default: the DOCKERHUB_NAMESPACE ' +
                 'environment variable.',
             type: 'string',
-        })
-            .option('github-repository', {
-            describe: 'The "owner/repo" GitHub Releases are created in - default: each package\'s own ' +
-                '"publish.github.repository", falling back to the "origin" remote.',
-            type: 'string',
         }),
         handler: async (args) => {
             await assertAllowedBranch(repository, readBranchGuardOptions(args));
             const targets = resolveTargets(args.target);
             const explicitTargets = !!args.target?.length;
             const explicitDockerTarget = explicitTargets && targets.has('docker');
-            const explicitGithubTarget = explicitTargets && targets.has('github');
             const ignoreDirty = args.ignoreDirty;
             const npmOptions = {
                 ...readPackageFilterOptions(args),
@@ -100,23 +92,14 @@ export function initCli(repository, program) {
                 ignoreDirty,
                 namespace: args.dockerNamespace,
             };
-            // No package filtering: a GitHub Release belongs to the repository, not to a package, so
-            // there is nothing for --scope/--ignore to narrow down.
-            const githubOptions = { ignoreDirty, repository: args.githubRepository };
             const npmPlan = targets.has('npm') ? await PublishService.getPlan(repository, npmOptions) : [];
             const dockerPlan = targets.has('docker') ? await DockerPublishService.getPlan(repository, dockerOptions) : [];
-            const githubPlan = targets.has('github') ? await GithubReleaseService.getPlan(repository, githubOptions) : [];
             if (args.json) {
-                console.log(JSON.stringify([
-                    ...npmPlan.map(e => jsonEntry(e, 'npm')),
-                    ...dockerPlan.map(e => jsonEntry(e, 'docker')),
-                    ...githubPlan.map(e => jsonEntry(e, 'github')),
-                ], undefined, 2));
+                console.log(JSON.stringify([...npmPlan.map(e => jsonEntry(e, 'npm')), ...dockerPlan.map(e => jsonEntry(e, 'docker'))], undefined, 2));
             }
             else {
                 printPlan(npmPlan);
                 printPlan(dockerPlan, 'docker');
-                printPlan(githubPlan, 'github');
             }
             if (explicitDockerTarget && !dockerPlan.length) {
                 const message = '--target docker was given, but no package\'s .rmanrc configures "publish.docker".';
@@ -125,14 +108,7 @@ export function initCli(repository, program) {
                 err.logged = true;
                 throw err;
             }
-            if (explicitGithubTarget && !githubPlan.length) {
-                const message = '--target github was given, but nothing in .rmanrc opts into the "github" target.';
-                console.log(colors.red(message));
-                const err = new Error(message);
-                err.logged = true;
-                throw err;
-            }
-            const errors = [...npmPlan, ...dockerPlan, ...githubPlan].filter(e => e.status === 'error');
+            const errors = [...npmPlan, ...dockerPlan].filter(e => e.status === 'error');
             if (errors.length) {
                 const allDirty = errors.every(e => e.reason === 'uncommitted local changes');
                 const message = allDirty
@@ -144,7 +120,7 @@ export function initCli(repository, program) {
                 err.logged = true;
                 throw err;
             }
-            if (![...npmPlan, ...dockerPlan, ...githubPlan].some(e => e.status === 'publish')) {
+            if (![...npmPlan, ...dockerPlan].some(e => e.status === 'publish')) {
                 if (!args.json)
                     console.log(colors.gray('Nothing to publish.'));
                 return;
@@ -172,7 +148,6 @@ export function initCli(repository, program) {
                 })
                 : [];
             const appliedDocker = targets.has('docker') ? await DockerPublishService.applyPlan(repository, dockerPlan) : [];
-            const appliedGithub = targets.has('github') ? await GithubReleaseService.applyPlan(repository, githubPlan) : [];
             let failed = false;
             for (const entry of appliedNpm) {
                 if (entry.status === 'publish') {
@@ -193,16 +168,6 @@ export function initCli(repository, program) {
                     console.log(colors.red('failed'), colors.gray('[docker]'), colors.cyan(entry.package.name), colors.red(entry.reason ?? ''));
                 }
             }
-            for (const entry of appliedGithub) {
-                if (entry.status === 'publish') {
-                    console.log(colors.green('released'), colors.gray('[github]'), colors.cyan(entry.tag ?? ''));
-                }
-                else if (entry.status === 'error' &&
-                    githubPlan.find(e => e.package === entry.package)?.status === 'publish') {
-                    failed = true;
-                    console.log(colors.red('failed'), colors.gray('[github]'), colors.cyan(entry.package.name), colors.red(entry.reason ?? ''));
-                }
-            }
             if (failed) {
                 const err = new Error('"publish" failed');
                 err.logged = true;
@@ -213,7 +178,7 @@ export function initCli(repository, program) {
 }
 function resolveTargets(input) {
     if (!input?.length)
-        return new Set(['npm', 'docker', 'github']);
+        return new Set(['npm', 'docker']);
     return new Set(input);
 }
 /** One `--json` row. `target` is what distinguishes otherwise-identical rows for a package that

package/constants.js

@@ -1 +1 @@
-export const version = '1.0.9';
+export const version = '1.0.10';

package/interfaces/rman-config.interface.d.ts

@@ -16,6 +16,7 @@ export interface RmanConfig {
     changelog?: RmanConfig.ChangelogOptions;
     clean?: RmanConfig.CleanOptions;
     publish?: RmanConfig.PublishOptions;
+    githubRelease?: RmanConfig.GithubReleaseOptions;
     /** Keyed by npm script name (e.g. `"build"`, `"lint"`, `"test"`). */
     run?: Record<string, RmanConfig.RunScriptOptions>;
     /** Keyed by the in-repo package's own name. */
@@ -68,17 +69,18 @@ export declare namespace RmanConfig {
         dependencies?: string[] | Record<string, string>;
     }
     interface PublishOptions {
-        /** Where `publish` should release this package to - default `['npm']` (every existing repo
+        /** Which **registry** `publish` ships this package to - default `['npm']` (every existing repo
          *  keeps working unchanged). A package that only ever wants Docker images (typically also
-         *  `"private": true`, since it's not meant for npm at all) sets `['docker']`; a standalone app
-         *  shipped as GitHub Release assets - or deployed elsewhere entirely, with the release only
-         *  recording that it happened - sets `['github']`; any combination works (`['npm', 'github']`).
+         *  `"private": true`, since it's not meant for npm at all) sets `['docker']`; both works too.
          *  Each target answers "is this version already out there?" against its own registry, so a
-         *  package is never left without one: npm via `npm view`, docker via `docker manifest inspect`,
-         *  github via the release for that version's tag. */
+         *  package is never left without one: npm via `npm view`, docker via `docker manifest inspect`.
+         *
+         *  Note this is strictly about *package distribution*. The repository's GitHub Release is not
+         *  a target here - it isn't a place a package ships to, it's the repository's own record that
+         *  a release happened, and it is never opted into: see `githubRelease` and the
+         *  `github-release` command. */
         target?: PublishTarget | PublishTarget[];
         docker?: DockerPublishOptions;
-        github?: GithubPublishOptions;
         /** Excludes this package from `publish` entirely (every target), 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
@@ -87,7 +89,7 @@ export declare namespace RmanConfig {
          *  package can still be meaningfully versioned without ever being published. */
         skip?: boolean;
     }
-    type PublishTarget = 'npm' | 'docker' | 'github';
+    type PublishTarget = 'npm' | 'docker';
     /** Required once `"docker"` is one of this package's `publish.target`s - `publish --target
      *  docker` errors clearly on a package that opts in here but leaves this out. */
     interface DockerPublishOptions {
@@ -112,19 +114,22 @@ export declare namespace RmanConfig {
          *  full description, if present. Default `"DOCKER_README.md"`. */
         readme?: string;
     }
-    /** Optional even when `"github"` is one of this package's `publish.target`s - unlike docker,
-     *  every required fact (which tag, which repository, what release notes) already has a sensible
-     *  source, so a bare `"target": ["github"]` is a complete configuration on its own. */
-    interface GithubPublishOptions {
+    /** Entirely optional - `github-release` needs no configuration at all, since every required fact
+     *  (which tag, which repository, what the notes say) already has a sensible source. Nothing here
+     *  decides *whether* a release is cut: a release records that the repository shipped, so it is
+     *  always cut, and these are only details about how. */
+    interface GithubReleaseOptions {
         /** Files to attach to the release, as glob patterns relative to the package's own directory
-         *  (e.g. `["dist/*.tar.gz"]`). A release with no assets is still perfectly valid - it records
-         *  that the version shipped, which is all a deploy-elsewhere package needs. */
+         *  (e.g. `["dist/*.tar.gz"]`). Read from **every** package, since one release covers the whole
+         *  source tree. A release with no assets at all is still perfectly valid - it records that the
+         *  version shipped, which is all a deploy-elsewhere package needs. */
         assets?: string[];
-        /** `owner/repo`. Default: parsed from the `origin` remote's URL. */
+        /** `owner/repo`. Default: parsed from the `origin` remote's URL. Root-level only. */
         repository?: string;
-        /** Create the release as an unpublished draft. Default `false`. */
+        /** Create the release as an unpublished draft. Default `false`. Root-level only. */
         draft?: boolean;
-        /** Default: whether the version being released is itself a semver prerelease (`1.3.0-beta.0`). */
+        /** Default: whether the version being released is itself a semver prerelease (`1.3.0-beta.0`).
+         *  Root-level only. */
         prerelease?: boolean;
     }
 }

package/package.json

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

package/rmanrc.schema.json

@@ -131,11 +131,11 @@
     },
     "publish": {
       "type": "object",
-      "description": "Options for the \"publish\" command/PublishService, DockerPublishService and GithubReleaseService. Per-package cascaded.",
+      "description": "Options for the \"publish\" command/PublishService and DockerPublishService. Per-package cascaded.",
       "additionalProperties": false,
       "properties": {
         "target": {
-          "description": "Where \"publish\" releases this package to. Default [\"npm\"]. A package that only ships Docker images (typically also \"private\": true) sets [\"docker\"]; a standalone app shipped as GitHub Release assets - or deployed elsewhere, with the release only recording that it shipped - sets [\"github\"]; any combination works. Each target answers \"is this version already out there?\" against its own registry: npm via \"npm view\", docker via \"docker manifest inspect\", github via the release for that version's tag.",
+          "description": "Which registry \"publish\" ships this package to. Default [\"npm\"]. A package that only ships Docker images (typically also \"private\": true) sets [\"docker\"]; both works too. Each target answers \"is this version already out there?\" against its own registry: npm via \"npm view\", docker via \"docker manifest inspect\". This is strictly about package distribution - the repository's GitHub Release is not a target here, see \"githubRelease\" and the \"github-release\" command.",
           "default": [
             "npm"
           ],
@@ -155,10 +155,6 @@
           "$ref": "#/definitions/dockerPublishConfig",
           "description": "Required once \"docker\" is one of this package's \"publish.target\"s."
         },
-        "github": {
-          "$ref": "#/definitions/githubPublishConfig",
-          "description": "Optional even when \"github\" is one of this package's \"publish.target\"s - every required fact already has a sensible default source."
-        },
         "skip": {
           "type": "boolean",
           "default": false,
@@ -166,6 +162,10 @@
         }
       }
     },
+    "githubRelease": {
+      "$ref": "#/definitions/githubReleaseConfig",
+      "description": "Details of the repository's GitHub Release (\"github-release\"/GithubReleaseService). Entirely optional - every required fact already has a sensible default source. Nothing here decides whether a release is cut: a release records that the repository shipped, so it is always cut. \"assets\" is per-package cascaded; the rest is root-level only."
+    },
     "run": {
       "type": "object",
       "description": "Per-script options for \"run\"/\"build\"/\"test\"/RunService, keyed by npm script name (e.g. \"build\", \"lint\", \"test\").",
@@ -230,8 +230,7 @@
       "type": "string",
       "enum": [
         "npm",
-        "docker",
-        "github"
+        "docker"
       ]
     },
     "dockerPublishConfig": {
@@ -286,7 +285,7 @@
         }
       }
     },
-    "githubPublishConfig": {
+    "githubReleaseConfig": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
@@ -295,7 +294,7 @@
           "items": {
             "type": "string"
           },
-          "description": "Files to attach to the release, as glob patterns relative to the package's own directory (e.g. [\"dist/*.tar.gz\"]). A release with no assets is still valid."
+          "description": "Files to attach to the release, as glob patterns relative to the package's own directory (e.g. [\"dist/*.tar.gz\"]). Read from every package, since one release covers the whole source tree. A release with no assets is still valid."
         },
         "repository": {
           "type": "string",

package/services/github-release.service.d.ts

@@ -11,7 +11,7 @@ export declare namespace GithubReleaseService {
         /** Uncommitted local changes anywhere in the repository make the release `'skip'` instead of
          *  `'error'` - same as `version`/`publish`'s other targets. */
         ignoreDirty?: boolean;
-        /** `owner/repo` override - otherwise the root's own `publish.github.repository`, falling back
+        /** `owner/repo` override - otherwise the root's own `githubRelease.repository`, falling back
          *  to the `origin` remote's URL. */
         repository?: string;
     }
@@ -31,13 +31,14 @@ export declare namespace GithubReleaseService {
         reason?: string;
     }
     /**
-     * Computes what `publish --target github` *would* do - **one** release per run, or none.
+     * Computes what `github-release` *would* do - **one** release per run.
      *
      * A GitHub Release is a property of the repository, not of a package: the tag covers the whole
-     * source tree, so everything that shipped under it belongs in it. That makes the `"github"`
-     * target a repository-level opt-in (typically in the root `.rmanrc`, alongside `"npm"`); it's
-     * honored as soon as *any* package resolves it, since a per-package release would have to invent
-     * a tag no package owns.
+     * source tree, so everything that shipped under it belongs in it. There is deliberately **no
+     * opt-in**: it isn't a place a package ships to (that's `publish.target`, which is about
+     * registries - npm, Docker Hub, GitHub Packages), it's the repository's own record that a
+     * release happened, and a repository always wants that record. Re-running is harmless - an
+     * existing release for the tag reads `'up-to-date'`.
      *
      * The release is identified by the repository's own version (the root's - see
      * `VersionService`'s `buildRootEntry`): its release tag when that version is a calendar one, and
@@ -52,9 +53,9 @@ export declare namespace GithubReleaseService {
      */
     function getPlan(repository: Repository, options?: Options, deps?: Deps): Promise<Entry[]>;
     /**
-     * Creates the repository's GitHub Release, then uploads whatever `publish.github.assets` globs
-     * match. The body covers **every** package that shipped under this release - not just the ones
-     * naming `"github"` as a target - since the tag covers all of their code either way.
+     * Creates the repository's GitHub Release, then uploads whatever `githubRelease.assets` globs
+     * match, across every package. The body covers **every** package that shipped under this
+     * release, since the tag covers all of their code either way.
      *
      * Each package's notes are bounded by the *previous repository release*, and headed with that
      * package's own version, so a repo whose packages sit on different version lines still reads

package/services/github-release.service.js

@@ -9,13 +9,14 @@ import { ChangelogService } from './changelog.service.js';
 export var GithubReleaseService;
 (function (GithubReleaseService) {
     /**
-     * Computes what `publish --target github` *would* do - **one** release per run, or none.
+     * Computes what `github-release` *would* do - **one** release per run.
      *
      * A GitHub Release is a property of the repository, not of a package: the tag covers the whole
-     * source tree, so everything that shipped under it belongs in it. That makes the `"github"`
-     * target a repository-level opt-in (typically in the root `.rmanrc`, alongside `"npm"`); it's
-     * honored as soon as *any* package resolves it, since a per-package release would have to invent
-     * a tag no package owns.
+     * source tree, so everything that shipped under it belongs in it. There is deliberately **no
+     * opt-in**: it isn't a place a package ships to (that's `publish.target`, which is about
+     * registries - npm, Docker Hub, GitHub Packages), it's the repository's own record that a
+     * release happened, and a repository always wants that record. Re-running is harmless - an
+     * existing release for the tag reads `'up-to-date'`.
      *
      * The release is identified by the repository's own version (the root's - see
      * `VersionService`'s `buildRootEntry`): its release tag when that version is a calendar one, and
@@ -30,18 +31,15 @@ export var GithubReleaseService;
      */
     async function getPlan(repository, options = {}, deps = {}) {
         const root = repository.rootPackage;
-        const wanted = [root, ...repository.getPackages()].some(pkg => targetsGithub(pkg) && !pkg.config.publish?.skip);
-        if (!wanted)
-            return [];
         const git = new GitHelper({ cwd: repository.dirname });
         const base = { package: root, version: root.version };
-        const repo = options.repository ?? root.config?.publish?.github?.repository ?? repoFromRemoteUrl(await git.remoteUrl());
+        const repo = options.repository ?? root.config?.githubRelease?.repository ?? repoFromRemoteUrl(await git.remoteUrl());
         if (!repo) {
             return [
                 {
                     ...base,
                     status: 'error',
-                    reason: 'cannot resolve "owner/repo" - set "publish.github.repository" or an "origin" remote',
+                    reason: 'cannot resolve "owner/repo" - set "githubRelease.repository" or an "origin" remote',
                 },
             ];
         }
@@ -91,9 +89,9 @@ export var GithubReleaseService;
     }
     GithubReleaseService.getPlan = getPlan;
     /**
-     * Creates the repository's GitHub Release, then uploads whatever `publish.github.assets` globs
-     * match. The body covers **every** package that shipped under this release - not just the ones
-     * naming `"github"` as a target - since the tag covers all of their code either way.
+     * Creates the repository's GitHub Release, then uploads whatever `githubRelease.assets` globs
+     * match, across every package. The body covers **every** package that shipped under this
+     * release, since the tag covers all of their code either way.
      *
      * Each package's notes are bounded by the *previous repository release*, and headed with that
      * package's own version, so a repo whose packages sit on different version lines still reads
@@ -113,7 +111,7 @@ export var GithubReleaseService;
             const release = await createOrUpdateRelease(entry.repository, entry.tag, {
                 name: entry.tag,
                 body,
-                draft: !!repository.rootPackage.config?.publish?.github?.draft,
+                draft: !!repository.rootPackage.config?.githubRelease?.draft,
                 prerelease: resolvePrerelease(repository.rootPackage, entry.version),
             });
             await uploadAssets(repository, entry.repository, release.id);
@@ -127,11 +125,6 @@ export var GithubReleaseService;
 })(GithubReleaseService || (GithubReleaseService = {}));
 const GITHUB_API = 'https://api.github.com';
 const GITHUB_UPLOADS = 'https://uploads.github.com';
-function targetsGithub(pkg) {
-    const target = pkg.config.publish?.target;
-    const targets = Array.isArray(target) ? target : target ? [target] : ['npm'];
-    return targets.includes('github');
-}
 /** The tag naming this repository's release. A calendar root version means several version lines,
  *  so the release needs a name of its own (`release-*`); a plain one means every package shares it,
  *  and that shared version's tag already *is* the release. */
@@ -144,7 +137,7 @@ function releaseTagGlob(root) {
     return pattern.replace('{name}', root.name);
 }
 function resolvePrerelease(root, version) {
-    const configured = root.config?.publish?.github?.prerelease;
+    const configured = root.config?.githubRelease?.prerelease;
     // A calendar version's time part is a semver prerelease identifier by construction - it says
     // nothing about the release being a preview, so it must not be read as one.
     return configured ?? (!isCalendarVersion(version) && !!semver.prerelease(version));
@@ -242,12 +235,12 @@ async function createOrUpdateRelease(repository, tag, fields) {
     }
     return release;
 }
-/** Every `publish.github.assets` glob across the repository, each resolved against its own
+/** Every `githubRelease.assets` glob across the repository, each resolved against its own
  *  package's directory - an app ships its artifacts from its own folder, but they all land on the
  *  one release the repository cut. */
 async function uploadAssets(repository, repo, releaseId) {
     for (const pkg of [repository.rootPackage, ...repository.getPackages()]) {
-        const patterns = pkg.config.publish?.github?.assets;
+        const patterns = pkg.config.githubRelease?.assets;
         if (!patterns?.length)
             continue;
         const files = await fastGlob(patterns, { cwd: pkg.dirname, absolute: true, onlyFiles: true });

package/utils/change-hash.d.ts

@@ -15,8 +15,8 @@ export declare function tagPattern(pkg: Package): string;
 export declare function findLatestTag(git: GitHelper, pkg: Package): Promise<string | undefined>;
 /** The forward direction of `findLatestTag`: expands `pkg`'s (cascaded) `.rmanrc
  *  changelog.tagPattern` into the concrete tag name `version` belongs under - `{name}` becomes the
- *  package's own name, `*` becomes `version`. Shared by `version` (creating the tag), `publish
- *  --target github` (finding the release that tag belongs to), and `detectChangeHash`'s own npm
+ *  package's own name, `*` becomes `version`. Shared by `version` (creating the tag),
+ *  `github-release` (finding the release that tag belongs to), and `detectChangeHash`'s own npm
  *  fallback (mapping a published version back onto a tag), so all three name tags identically. */
 export declare function expandTag(pkg: Package, version: string): string;
 /** The pattern expansion `expandTag` performs, on any pattern - `{name}` becomes `name`, `*` becomes

package/utils/change-hash.js

@@ -22,8 +22,8 @@ export async function findLatestTag(git, pkg) {
 }
 /** The forward direction of `findLatestTag`: expands `pkg`'s (cascaded) `.rmanrc
  *  changelog.tagPattern` into the concrete tag name `version` belongs under - `{name}` becomes the
- *  package's own name, `*` becomes `version`. Shared by `version` (creating the tag), `publish
- *  --target github` (finding the release that tag belongs to), and `detectChangeHash`'s own npm
+ *  package's own name, `*` becomes `version`. Shared by `version` (creating the tag),
+ *  `github-release` (finding the release that tag belongs to), and `detectChangeHash`'s own npm
  *  fallback (mapping a published version back onto a tag), so all three name tags identically. */
 export function expandTag(pkg, version) {
     return applyTagPattern(tagPattern(pkg), pkg.name, version);