@wpelevator/wp-release 0.15.0 → 0.16.0

package/dist/changeset-release.js

@@ -1,3 +1,4 @@
+import { resolveSingleProjectConfig } from "./single-project.js";
 import path from 'node:path';
 import { getVersionedReleases, prependChangelog } from "./changelog.js";
 import { loadChangesetConfig } from "./changeset-config.js";
@@ -12,7 +13,7 @@ import { ReleaseRepository } from "./release-repository.js";
 import { DEFAULT_TAG_FORMAT, formatTag } from "./tag-format.js";
 import { verifyVersionTargets, writeVersion } from "./version-files.js";
 import { getPrereleaseVersion, getSnapshotVersion, isPrerelease, } from "./versions.js";
-const MISSING_CONFIG = 'No wp-release config found. Add wp-release.config.js or pass --config <path>.';
+const MISSING_CONFIG = 'No wp-release config or root project found. Pass --version-* descriptors, add wp-release.config.js or pass --config <path>.';
 /**
  * Changeset releases of a repository: recording changesets, versioning the
  * packages they name and tagging the releases.
@@ -24,6 +25,7 @@ const MISSING_CONFIG = 'No wp-release config found. Add wp-release.config.js or
 export class ChangesetRelease {
     cwd;
     configFile;
+    singleProject;
     tagFormat;
     repository;
     /**
@@ -32,6 +34,7 @@ export class ChangesetRelease {
     constructor(options) {
         this.cwd = options.cwd;
         this.configFile = options.configFile;
+        this.singleProject = options.singleProject;
         this.tagFormat = options.tagFormat;
         this.repository = new ReleaseRepository({
             cwd: options.cwd,
@@ -42,7 +45,7 @@ export class ChangesetRelease {
      * Discover configured packages, pending changesets, and their proposed
      * versions.
      *
-     * @return A release plan; `undefined` when no config is present.
+     * @return A release plan; `undefined` without a config or a recognized root project.
      */
     async getPlan() {
         const context = await this.loadContext();
@@ -361,19 +364,14 @@ export class ChangesetRelease {
      * Load the configuration, discover the packages and plan the releases of
      * the pending changesets, including the releases of their dependents.
      *
-     * @return Release context, undefined without a config.
+     * @return Release context, undefined without a config or a recognized root project.
      * @throws {ValidationError} For an invalid config, plan or changeset.
      */
     async loadContext() {
-        const loaded = await loadChangesetConfig({
-            cwd: this.cwd,
-            ...(this.configFile ? { configFile: this.configFile } : {}),
-            ...(this.tagFormat ? { tagFormat: this.tagFormat } : {}),
-        });
-        if (!loaded) {
+        const config = await this.loadConfig();
+        if (!config) {
             return undefined;
         }
-        const config = loaded.config;
         const packages = await discoverPackages(this.repository, config);
         const changesets = await readChangesets(this.getChangesetDirectory(config));
         const releases = [];
@@ -431,15 +429,26 @@ export class ChangesetRelease {
      * @throws {ValidationError} Without a config.
      */
     async requireConfig() {
+        const config = await this.loadConfig();
+        if (!config) {
+            throw new ValidationError(MISSING_CONFIG);
+        }
+        return config;
+    }
+    /** Load an explicit/discovered config, otherwise resolve one root project. */
+    async loadConfig() {
         const loaded = await loadChangesetConfig({
             cwd: this.cwd,
             ...(this.configFile ? { configFile: this.configFile } : {}),
             ...(this.tagFormat ? { tagFormat: this.tagFormat } : {}),
         });
-        if (!loaded) {
-            throw new ValidationError(MISSING_CONFIG);
+        if (loaded) {
+            if (this.singleProject) {
+                throw new ValidationError('Single-project options cannot be combined with a wp-release config. Set these options in the config instead.');
+            }
+            return loaded.config;
         }
-        return loaded.config;
+        return resolveSingleProjectConfig(this.cwd, this.singleProject, this.tagFormat);
     }
     /**
      * Get the directory of the changeset files.
@@ -455,7 +464,7 @@ export class ChangesetRelease {
  * Discover configured packages, pending changesets, and their proposed versions.
  *
  * @param input Repository root and optional explicit config file.
- * @return A release plan; `undefined` when no config is present.
+ * @return A release plan; `undefined` without a config or a recognized root project.
  */
 export async function getChangesetReleasePlan(input) {
     return new ChangesetRelease(input).getPlan();

package/dist/cli.d.ts

@@ -59,6 +59,7 @@ export declare function formatGitHubOutputs(result: unknown): string;
  * Results of the commands that can be run with execute(), by command name.
  */
 export interface CommandResults {
+    build: import('./commands/build.ts').BuildResult;
     'deploy-svn': import('./commands/deploy-svn.ts').DeploySvnResult;
     zip: ZipResult;
     checksums: ChecksumsResult;

package/dist/cli.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { appendFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';
 import zip from "./commands/zip.js";
+import build from "./commands/build.js";
 import checksums from "./commands/checksums.js";
 import sign from "./commands/sign.js";
 import keygen from "./commands/keygen.js";
@@ -22,6 +23,7 @@ export const EXIT_SUCCESS = 0;
 export const EXIT_FAILURE = 1;
 export const EXIT_INVALID = 2;
 export const commands = [
+    build,
     zip,
     checksums,
     sign,

package/dist/commands/artifact-signing.d.ts

@@ -0,0 +1,20 @@
+import type { ParseArgsOptionsConfig } from 'node:util';
+import type { SignFilesInput, SignatureFormat } from '../signing.ts';
+import type { ParsedValues } from './command.ts';
+export declare const checksumSigningArgs: ParseArgsOptionsConfig;
+interface SigningPaths {
+    artifact?: string;
+    checksums: string;
+}
+/**
+ * Resolve explicit signing targets and validate them before creating artifacts.
+ *
+ * @param  values Parsed CLI flags.
+ * @param  paths  Artifact and manifest paths that can be signed.
+ * @return Signing input, or undefined when no signing is requested.
+ * @throws {ValidationError} For formats without a signing target or invalid signing input.
+ */
+export declare function getArtifactSigning(values: ParsedValues, paths: SigningPaths): (SignFilesInput & {
+    formats: SignatureFormat[];
+}) | undefined;
+export {};

package/dist/commands/artifact-signing.js

@@ -0,0 +1,42 @@
+import { ValidationError } from "../errors.js";
+import { checkSigningInput } from "../signing.js";
+import { parseSignatureFormats } from "./args.js";
+import { getBoolean, getStrings } from "./command.js";
+export const checksumSigningArgs = {
+    checksums: { type: 'boolean' },
+    'sign-checksums': { type: 'boolean' },
+    'sign-format': { type: 'string', multiple: true },
+};
+/**
+ * Resolve explicit signing targets and validate them before creating artifacts.
+ *
+ * @param  values Parsed CLI flags.
+ * @param  paths  Artifact and manifest paths that can be signed.
+ * @return Signing input, or undefined when no signing is requested.
+ * @throws {ValidationError} For formats without a signing target or invalid signing input.
+ */
+export function getArtifactSigning(values, paths) {
+    const names = getStrings(values, 'sign-format');
+    const targets = [
+        ...(getBoolean(values, 'sign') && paths.artifact
+            ? [paths.artifact]
+            : []),
+        ...(getBoolean(values, 'sign-checksums')
+            ? [paths.checksums]
+            : []),
+    ];
+    if (names.length && !targets.length) {
+        throw new ValidationError('--sign-format requires --sign or --sign-checksums; it does not enable signing.');
+    }
+    const signing = targets.length
+        ? {
+            paths: targets,
+            formats: parseSignatureFormats(names),
+            force: getBoolean(values, 'force'),
+        }
+        : undefined;
+    if (signing) {
+        checkSigningInput(signing);
+    }
+    return signing;
+}

package/dist/commands/build.d.ts

@@ -0,0 +1,32 @@
+import type { BuildPackageResult } from '../package-build.ts';
+import type { CommandOutcome } from './command.ts';
+export interface BuildResult extends BuildPackageResult {
+    package?: string;
+    signatures?: string[];
+    publicKey?: string;
+}
+declare const _default: {
+    name: string;
+    usage: string;
+    summary: string;
+    help: string;
+    options: {
+        package: {
+            type: "string";
+        };
+        force: {
+            type: "boolean";
+        };
+        output: {
+            type: "string";
+        };
+        slug: {
+            type: "string";
+        };
+        version: {
+            type: "string";
+        };
+    };
+    run({ values, positionals, cwd, configFile, logger, }: import("./command.ts").CommandContext): Promise<CommandOutcome<BuildResult>>;
+};
+export default _default;

package/dist/commands/build.js

@@ -0,0 +1,91 @@
+import { checksumSigningArgs, getArtifactSigning } from "./artifact-signing.js";
+import { signFiles } from "../signing.js";
+import { resolve } from 'node:path';
+import { getBuildSummary, getSignSummary } from "../summary.js";
+import { ValidationError } from "../errors.js";
+import { buildPackage, getBuildChecksumsPath } from "../package-build.js";
+import { fileSelectionArgs, sourceDirArgs } from "./args.js";
+import { getBoolean, getString } from "./command.js";
+import { getDirectorySource, getPackageArg, getPackageSource, } from "./package-source.js";
+export default {
+    name: 'build',
+    usage: 'build [<source-dir>] --output <dir> [options] | build --package <name> --output <dir>',
+    summary: 'Copy the selected release files into an output directory.',
+    help: `Options:
+  --output <dir>             Required destination; files go directly inside it
+  --source-dir <dir>         Source directory (default: .), or a positional argument
+  --package <name>           Use the configured package directory and file rules
+  --distignore <file>        Ignore file (default: <source-dir>/.distignore)
+  --no-distignore            Don't read an ignore file
+  --exclude <patterns>       Extra patterns, comma-separated or repeated
+  --exclude-gitattributes    Exclude Git export-ignore paths
+  --slug <slug>             Slug in the manifest (default: project directory name)
+  --version <version>       Manifest version (default: Version header)
+  --checksums               Write <output-dir>.checksums.json beside the directory
+  --sign-checksums           Generate and sign the manifest; implies --checksums
+  --sign-format <names>     Formats: wordpress,minisign,ssh; requires --sign-checksums
+  --force                   Replace an existing output directory, removing stale files
+
+The output directory is excluded from the source selection. It cannot be the
+source directory or an ancestor. --sign is unsupported for directories.
+
+Examples:
+  wp-release build --output dist/my-plugin
+  wp-release build --package plugins/alpha --output dist/alpha`,
+    options: {
+        output: { type: 'string' },
+        slug: { type: 'string' },
+        version: { type: 'string' },
+        ...checksumSigningArgs,
+        ...sourceDirArgs,
+        ...fileSelectionArgs,
+        package: { type: 'string' },
+        force: { type: 'boolean' },
+    },
+    async run({ values, positionals, cwd, configFile, logger, }) {
+        const output = getString(values, 'output');
+        if (!output?.trim()) {
+            throw new ValidationError('build requires --output <dir>.');
+        }
+        const name = getPackageArg(values, positionals);
+        const source = name
+            ? await getPackageSource(values, cwd, name, configFile)
+            : await getDirectorySource(values, positionals, cwd);
+        const outputDir = resolve(cwd, output);
+        const signing = getArtifactSigning(values, {
+            checksums: getBuildChecksumsPath(outputDir),
+        });
+        const built = await buildPackage({
+            sourceDir: source.sourceDir,
+            selection: source.selection,
+            outputDir,
+            checksums: getBoolean(values, 'checksums') ||
+                getBoolean(values, 'sign-checksums'),
+            slug: source.slug,
+            version: source.version,
+            ...(source.type ? { type: source.type } : {}),
+            force: getBoolean(values, 'force'),
+        });
+        const signed = signing
+            ? { ...(await signFiles(signing)), formats: signing.formats }
+            : undefined;
+        const result = {
+            ...built,
+            ...(signed
+                ? { signatures: signed.signatures, publicKey: signed.publicKey }
+                : {}),
+            ...(source.package ? { package: source.package } : {}),
+        };
+        logger.debug(`Built ${built.files} files from ${source.sourceDir}.`);
+        logger.info(built.outputDir);
+        if (built.checksumsPath) {
+            logger.info(built.checksumsPath);
+        }
+        signed?.signatures.forEach((path) => logger.info(path));
+        logger.summary((context) => getBuildSummary(context, result));
+        if (signed) {
+            logger.summary((context) => getSignSummary(context, signed));
+        }
+        return { exitCode: 0, result };
+    },
+};

package/dist/commands/changeset-add.d.ts

@@ -8,24 +8,73 @@ declare const _default: {
     summary: string;
     help: string;
     options: {
-        readonly package: {
+        'version-package-json': {
             readonly type: "string";
             readonly multiple: true;
         };
-        readonly bump: {
+        'version-composer-json': {
             readonly type: "string";
             readonly multiple: true;
         };
-        readonly summary: {
+        'version-wordpress-plugin': {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        'version-wordpress-theme': {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        'version-wordpress-stable-tag': {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        'version-php-constant': {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        'version-git-tag': {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        'version-from': {
+            readonly type: "string";
+        };
+        'base-branch': {
+            readonly type: "string";
+        };
+        remote: {
+            readonly type: "string";
+        };
+        'changesets-dir': {
+            readonly type: "string";
+        };
+        'readme-changelog': {
+            readonly type: "boolean";
+        };
+        'no-readme-changelog': {
+            readonly type: "boolean";
+        };
+        'changelog-insert-after': {
+            readonly type: "string";
+        };
+        package: {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        bump: {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        summary: {
             readonly type: "string";
         };
-        readonly empty: {
+        empty: {
             readonly type: "boolean";
         };
-        readonly since: {
+        since: {
             readonly type: "string";
         };
-        readonly name: {
+        name: {
             readonly type: "string";
         };
     };

package/dist/commands/changeset-add.js

@@ -1,3 +1,4 @@
+import { changesetProjectArgs, changesetProjectHelp, parseChangesetProjectArgs, } from "./changeset-project-args.js";
 import { resolvePackageNames } from "../changeset-packages.js";
 import { ChangesetPrompt } from "../changeset-prompt.js";
 import { ChangesetRelease } from "../changeset-release.js";
@@ -13,6 +14,12 @@ import { parseChangesetAddArgs, changesetAddArgs } from "./changeset-args.js";
  * @throws {ValidationError} If no changed package needs a changeset.
  */
 async function getChangedPackageBumps(release, input, bump) {
+    const packages = await release.getPackages();
+    if (!input.since &&
+        1 === packages.length &&
+        '.' === packages[0]?.path) {
+        return { [packages[0].name]: bump };
+    }
     const status = await release.getStatus({
         ...(input.since ? { since: input.since } : {}),
         uncommitted: true,
@@ -99,15 +106,17 @@ export default {
 
 Use --package and --bump pairs for package releases, or --empty for changes
 that should pass the status check without producing a release. A single
---bump without --package releases the packages that changed since the base
+--bump without --package selects the sole root package, or releases packages
+that changed since the base
 ref, including uncommitted files, and have no changeset yet. Without
 --package and --bump in a terminal, the command asks for the packages, with
-the changed ones preselected, their bumps and the release note.`,
-    options: changesetAddArgs,
+the changed ones preselected, their bumps and the release note.${changesetProjectHelp}`,
+    options: { ...changesetAddArgs, ...changesetProjectArgs },
     async run({ values, cwd, configFile, tagFormat, logger, terminal }) {
         const input = parseChangesetAddArgs(values);
         const release = new ChangesetRelease({
             cwd,
+            ...parseChangesetProjectArgs(values),
             ...(configFile ? { configFile } : {}),
             ...(tagFormat ? { tagFormat } : {}),
         });

package/dist/commands/changeset-args.js

@@ -193,8 +193,8 @@ export function parseChangesetTagArgs(values) {
     if ('' === args.version) {
         throw new ValidationError('--version <version> must not be empty.');
     }
-    if (undefined !== args.version && 1 !== args.packages.length) {
-        throw new ValidationError('--version <version> requires exactly one --package <name>.');
+    if (undefined !== args.version && args.packages.length > 1) {
+        throw new ValidationError('--version <version> accepts at most one --package <name>.');
     }
     if (args.untagged && args.push) {
         throw new ValidationError('--untagged cannot be combined with --push.');

package/dist/commands/changeset-project-args.d.ts

@@ -0,0 +1,63 @@
+import type { SingleProjectOptions } from '../single-project.ts';
+import type { ParsedValues } from './command.ts';
+export declare const changesetProjectArgs: {
+    readonly 'version-package-json': {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly 'version-composer-json': {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly 'version-wordpress-plugin': {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly 'version-wordpress-theme': {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly 'version-wordpress-stable-tag': {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly 'version-php-constant': {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly 'version-git-tag': {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly 'version-from': {
+        readonly type: "string";
+    };
+    readonly 'base-branch': {
+        readonly type: "string";
+    };
+    readonly remote: {
+        readonly type: "string";
+    };
+    readonly 'changesets-dir': {
+        readonly type: "string";
+    };
+    readonly 'readme-changelog': {
+        readonly type: "boolean";
+    };
+    readonly 'no-readme-changelog': {
+        readonly type: "boolean";
+    };
+    readonly 'changelog-insert-after': {
+        readonly type: "string";
+    };
+};
+export declare const changesetProjectHelp = "\nSingle-project options (without a release config file):\n  --version-package-json <file>             npm version source/target (repeatable)\n  --version-composer-json <file>            Composer source/target (repeatable)\n  --version-wordpress-plugin <file>         Plugin header source/target (repeatable)\n  --version-wordpress-theme <file>          Theme header source/target (repeatable)\n  --version-wordpress-stable-tag <file>     Readme Stable tag source/target (repeatable)\n  --version-php-constant <file>#<constant>  PHP constant source/target (repeatable)\n  --version-git-tag <pattern>               Git tag source only; use {version}\n  --version-from <kind>[:<file>]            Choose the source; constants use file#constant\n  --base-branch <branch>                   Default comparison branch on the remote\n  --remote <name>                          Git remote (default: origin)\n  --changesets-dir <dir>                   Changeset directory (default: .changeset)\n  --readme-changelog / --no-readme-changelog\n                                          Enable/disable readme changelog updates\n  --changelog-insert-after <marker>        Insert changelog entries after this marker\n\nExplicit descriptors define all version targets. Without them, detect one root\nproject. A unique non-Stable-tag descriptor is the inferred source; otherwise\npass --version-from, qualifying it with :file when its kind is repeated.\nUse the same project options for every changeset command.";
+/**
+ * Parse shared single-project settings; operation flags stay command-specific.
+ *
+ * @param values Parsed command arguments.
+ * @return Fallback settings when explicitly supplied.
+ */
+export declare function parseChangesetProjectArgs(values: ParsedValues): {
+    singleProject?: SingleProjectOptions;
+};

package/dist/commands/changeset-project-args.js

@@ -0,0 +1,114 @@
+import { packageJsonVersion, composerJsonVersion, wordpressPluginVersion, wordpressThemeVersion, wordpressStableTag, phpConstantVersion, gitTagVersion, } from "../changeset-config.js";
+import { ValidationError } from "../errors.js";
+import { getBoolean, getString, getStrings } from "./command.js";
+export const changesetProjectArgs = {
+    'version-package-json': { type: 'string', multiple: true },
+    'version-composer-json': { type: 'string', multiple: true },
+    'version-wordpress-plugin': { type: 'string', multiple: true },
+    'version-wordpress-theme': { type: 'string', multiple: true },
+    'version-wordpress-stable-tag': { type: 'string', multiple: true },
+    'version-php-constant': { type: 'string', multiple: true },
+    'version-git-tag': { type: 'string', multiple: true },
+    'version-from': { type: 'string' },
+    'base-branch': { type: 'string' },
+    remote: { type: 'string' },
+    'changesets-dir': { type: 'string' },
+    'readme-changelog': { type: 'boolean' },
+    'no-readme-changelog': { type: 'boolean' },
+    'changelog-insert-after': { type: 'string' },
+};
+export const changesetProjectHelp = `
+Single-project options (without a release config file):
+  --version-package-json <file>             npm version source/target (repeatable)
+  --version-composer-json <file>            Composer source/target (repeatable)
+  --version-wordpress-plugin <file>         Plugin header source/target (repeatable)
+  --version-wordpress-theme <file>          Theme header source/target (repeatable)
+  --version-wordpress-stable-tag <file>     Readme Stable tag source/target (repeatable)
+  --version-php-constant <file>#<constant>  PHP constant source/target (repeatable)
+  --version-git-tag <pattern>               Git tag source only; use {version}
+  --version-from <kind>[:<file>]            Choose the source; constants use file#constant
+  --base-branch <branch>                   Default comparison branch on the remote
+  --remote <name>                          Git remote (default: origin)
+  --changesets-dir <dir>                   Changeset directory (default: .changeset)
+  --readme-changelog / --no-readme-changelog
+                                          Enable/disable readme changelog updates
+  --changelog-insert-after <marker>        Insert changelog entries after this marker
+
+Explicit descriptors define all version targets. Without them, detect one root
+project. A unique non-Stable-tag descriptor is the inferred source; otherwise
+pass --version-from, qualifying it with :file when its kind is repeated.
+Use the same project options for every changeset command.`;
+/**
+ * Parse shared single-project settings; operation flags stay command-specific.
+ *
+ * @param values Parsed command arguments.
+ * @return Fallback settings when explicitly supplied.
+ */
+export function parseChangesetProjectArgs(values) {
+    const options = {};
+    const versions = [];
+    const factories = {
+        'package-json': packageJsonVersion,
+        'composer-json': composerJsonVersion,
+        'wordpress-plugin': wordpressPluginVersion,
+        'wordpress-theme': wordpressThemeVersion,
+        'wordpress-stable-tag': wordpressStableTag,
+    };
+    for (const [kind, factory] of Object.entries(factories)) {
+        for (const file of getStrings(values, `version-${kind}`)) {
+            if (!file.trim()) {
+                throw new ValidationError(`--version-${kind} <file> must not be empty.`);
+            }
+            versions.push(factory({ file }));
+        }
+    }
+    for (const value of getStrings(values, 'version-php-constant')) {
+        const separator = value.lastIndexOf('#');
+        const file = value.slice(0, separator);
+        const constant = value.slice(separator + 1);
+        if (separator < 1 ||
+            !file.trim() ||
+            !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(constant)) {
+            throw new ValidationError('--version-php-constant must be <file>#<constant>, for example plugin.php#PLUGIN_VERSION.');
+        }
+        versions.push(phpConstantVersion({ file, constant }));
+    }
+    const patterns = getStrings(values, 'version-git-tag');
+    if (patterns.length > 1) {
+        throw new ValidationError('--version-git-tag accepts one source pattern.');
+    }
+    for (const pattern of patterns) {
+        if (!pattern.trim() || !pattern.includes('{version}')) {
+            throw new ValidationError('--version-git-tag <pattern> must contain {version}.');
+        }
+        versions.push(gitTagVersion({ pattern }));
+    }
+    if (versions.length) {
+        options.versions = versions;
+    }
+    const strings = {
+        'version-from': 'versionFrom',
+        'base-branch': 'baseBranch',
+        remote: 'remote',
+        'changesets-dir': 'changesets',
+        'changelog-insert-after': 'changelogInsertAfter',
+    };
+    for (const [flag, key] of Object.entries(strings)) {
+        const value = getString(values, flag);
+        if (undefined !== value) {
+            if (!value.trim()) {
+                throw new ValidationError(`--${flag} must not be empty.`);
+            }
+            options[key] = value;
+        }
+    }
+    if (getBoolean(values, 'readme-changelog') &&
+        getBoolean(values, 'no-readme-changelog')) {
+        throw new ValidationError('--readme-changelog cannot be combined with --no-readme-changelog.');
+    }
+    if (getBoolean(values, 'readme-changelog') ||
+        getBoolean(values, 'no-readme-changelog')) {
+        options.readmeChangelog = getBoolean(values, 'readme-changelog');
+    }
+    return Object.keys(options).length ? { singleProject: options } : {};
+}