@wpelevator/wp-release 0.14.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

@@ -3,9 +3,8 @@ import type { SignResult } from './commands/sign.ts';
 import type { KeygenResult } from './commands/keygen.ts';
 import type { ZipResult } from './commands/zip.ts';
 import type { ChangesetVersionResult } from './commands/changeset-version.ts';
-import { Logger } from './logger.ts';
 import type { OutputStream } from './logger.ts';
-import type { Command, CommandOutcome } from './commands/command.ts';
+import type { CommandContext, Command, CommandOutcome } from './commands/command.ts';
 /** Input stream that interactive prompts read from in a terminal. */
 export type InputStream = NodeJS.ReadableStream & {
     isTTY?: boolean;
@@ -44,10 +43,24 @@ export declare function getCommandHelp(command: Command): string;
  * @return Command definition.
  */
 export declare function findCommand(args: string[]): Command | undefined;
+/**
+ * Format the result of a command as GitHub Actions step outputs: the whole
+ * result as JSON in "result", and each top-level string, number or boolean
+ * as its own output, like "zipPath", so that a workflow reads it without
+ * fromJSON(). Lists and objects are only in "result". Every value but the
+ * compact JSON, which has no line breaks, uses a random delimiter, so that a
+ * value with line breaks can't set other outputs.
+ *
+ * @param result Command result.
+ * @return Lines for the GITHUB_OUTPUT file.
+ */
+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;
     sign: SignResult;
@@ -68,14 +81,11 @@ export interface CommandResults {
  * @param  context.cwd        Working directory that relative paths resolve against.
  * @param  context.configFile Explicit config file path, when supplied by a wrapper.
  * @param  context.logger     Logger for the command output.
+ * @param  context.svnRunner  Optional SVN command runner supplied by a wrapper.
  * @return Exit code and result of the command.
  * @throws {Error} If the command is unknown, the arguments are invalid or the command fails.
  */
-export declare function execute<Name extends keyof CommandResults>(name: Name, args: string[], context: {
-    cwd: string;
-    logger: Logger;
-    configFile?: string;
-}): Promise<CommandOutcome<CommandResults[Name]>>;
+export declare function execute<Name extends keyof CommandResults>(name: Name, args: string[], context: Pick<CommandContext, 'cwd' | 'logger' | 'configFile' | 'svnRunner'>): Promise<CommandOutcome<CommandResults[Name]>>;
 /**
  * Run the CLI.
  *

package/dist/cli.js

@@ -1,6 +1,8 @@
+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";
@@ -21,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,
@@ -177,6 +180,28 @@ function createLogWriter(values, streams) {
     }
     return create(streams);
 }
+/**
+ * Format the result of a command as GitHub Actions step outputs: the whole
+ * result as JSON in "result", and each top-level string, number or boolean
+ * as its own output, like "zipPath", so that a workflow reads it without
+ * fromJSON(). Lists and objects are only in "result". Every value but the
+ * compact JSON, which has no line breaks, uses a random delimiter, so that a
+ * value with line breaks can't set other outputs.
+ *
+ * @param result Command result.
+ * @return Lines for the GITHUB_OUTPUT file.
+ */
+export function formatGitHubOutputs(result) {
+    const values = 'object' === typeof result && null !== result
+        ? Object.entries(result).filter(([name, value]) => 'result' !== name &&
+            ['string', 'number', 'boolean'].includes(typeof value))
+        : [];
+    const delimiter = `ghadelimiter_${randomUUID()}`;
+    return [
+        `result=${JSON.stringify(result)}\n`,
+        ...values.map(([name, value]) => `${name}<<${delimiter}\n${String(value)}\n${delimiter}\n`),
+    ].join('');
+}
 /**
  * Get the GitHub Actions step output file for --github-output, checked before
  * the command runs.
@@ -241,8 +266,7 @@ async function runCommand(command, args, io) {
             stdout.write(JSON.stringify(result, null, '\t') + '\n');
         }
         if (githubOutputFile) {
-            // Compact JSON has no line breaks, so it fits a single output line.
-            appendFileSync(githubOutputFile, `result=${JSON.stringify(result)}\n`);
+            appendFileSync(githubOutputFile, formatGitHubOutputs(result));
         }
         return exitCode;
     }
@@ -262,6 +286,7 @@ async function runCommand(command, args, io) {
  * @param  context.cwd        Working directory that relative paths resolve against.
  * @param  context.configFile Explicit config file path, when supplied by a wrapper.
  * @param  context.logger     Logger for the command output.
+ * @param  context.svnRunner  Optional SVN command runner supplied by a wrapper.
  * @return Exit code and result of the command.
  * @throws {Error} If the command is unknown, the arguments are invalid or the command fails.
  */

package/dist/commands/args.d.ts

@@ -1,4 +1,5 @@
 import type { ParseArgsOptionsConfig } from 'node:util';
+import type { SignatureFormat } from '../signing.ts';
 import type { ParsedValues } from './command.ts';
 /**
  * Options shared by the commands that select files with .distignore and
@@ -69,3 +70,13 @@ export interface ResolveOutputInput {
  * @return Absolute file path.
  */
 export declare function resolveOutput(input: ResolveOutputInput): string;
+/**
+ * Get the signature formats from the --format values of sign or the
+ * --sign-format values of zip, which can be repeated
+ * or comma-separated.
+ *
+ * @param  values Option values.
+ * @return Unique formats, the default when none are given.
+ * @throws {ValidationError} If a format is unknown.
+ */
+export declare function parseSignatureFormats(values: string[]): SignatureFormat[];

package/dist/commands/args.js

@@ -1,6 +1,7 @@
 import { stat } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { ValidationError } from "../errors.js";
+import { DEFAULT_SIGNATURE_FORMAT, SIGNATURE_FORMATS, isSignatureFormat, } from "../signing.js";
 import { getBoolean, getString, getStrings } from "./command.js";
 /**
  * Options shared by the commands that select files with .distignore and
@@ -95,3 +96,25 @@ export function getSourceDirArg(values, positionals) {
 export function resolveOutput(input) {
     return resolve(input.cwd, input.output ?? input.filename);
 }
+/**
+ * Get the signature formats from the --format values of sign or the
+ * --sign-format values of zip, which can be repeated
+ * or comma-separated.
+ *
+ * @param  values Option values.
+ * @return Unique formats, the default when none are given.
+ * @throws {ValidationError} If a format is unknown.
+ */
+export function parseSignatureFormats(values) {
+    const names = values
+        .flatMap((value) => value.split(','))
+        .map((name) => name.trim())
+        .filter(Boolean);
+    const unknown = names.filter((name) => !isSignatureFormat(name));
+    if (unknown.length) {
+        throw new ValidationError(`Unknown signature format ${unknown.join(', ')}, use ${Object.keys(SIGNATURE_FORMATS).join(', ')}.`);
+    }
+    return names.length
+        ? [...new Set(names.filter(isSignatureFormat))]
+        : [DEFAULT_SIGNATURE_FORMAT];
+}

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;
+};