@wpelevator/wp-release 0.15.0 → 0.17.0

package/dist/changeset-config.d.ts

@@ -1,3 +1,5 @@
+import type { I18nOptions } from './i18n/options.ts';
+import type { IntegrityConfig } from './integrity.ts';
 import type { Changeset, ChangesetBump, ChangesetPackage } from './changesets.ts';
 export type PackageVersionSource = {
     kind: 'package-json';
@@ -58,6 +60,8 @@ export interface PackageVersionConfig {
 export type PackageIdSource = 'package.json#name' | 'composer.json#name' | 'path';
 /** One directory pattern that describes packages sharing release behavior. */
 export interface ChangesetPackageGroup {
+    /** Extraction settings, independent of release file rules. */
+    i18n?: I18nOptions;
     /** Package directories to discover, relative to the configured package root. */
     glob: string;
     /** Package paths excluded from this group, relative to root. */
@@ -217,6 +221,10 @@ export interface DependentsConfig {
 }
 /** JavaScript configuration for changeset-aware releases. */
 export interface ChangesetConfig {
+    /** Extraction defaults for configured WordPress packages. */
+    i18n?: I18nOptions;
+    /** Default checksum format, placement and manifest signing for ZIPs. */
+    integrity?: IntegrityConfig;
     /** Branch receiving ordinary changes. */
     baseBranch?: string;
     /** Git remote that tags are pushed to and the base branch is compared on, origin by default. */

package/dist/changeset-config.js

@@ -6,6 +6,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
+import { validateI18nOptions } from "./i18n/options.js";
 import { access } from 'node:fs/promises';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -171,6 +172,7 @@ function validateChangesetConfig(config, configFile) {
         throw new ValidationError(`wp-release config ${configFile} must default-export a configuration object.`);
     }
     const candidate = config;
+    validateI18nOptions(candidate.i18n, `${configFile}.i18n`);
     if (!Array.isArray(candidate.packages)) {
         throw new ValidationError(`wp-release config ${configFile} must define a packages array.`);
     }
@@ -267,6 +269,7 @@ function validateChangesetConfig(config, configFile) {
                     !Array.isArray(group.version.to)))) {
             throw new ValidationError(`wp-release config ${configFile} has an invalid packages[${index}] entry.`);
         }
+        validateI18nOptions(group.i18n, `${configFile}.packages[${index}].i18n`);
         if (undefined !== group.idFrom &&
             !['path', 'package.json#name', 'composer.json#name'].includes(group.idFrom)) {
             throw new ValidationError(`wp-release config ${configFile} packages[${index}].idFrom is not supported.`);

package/dist/changeset-release.d.ts

@@ -1,9 +1,12 @@
+import type { SingleProjectOptions } from './single-project.ts';
 import type { Changeset, ChangesetBump, ChangesetPackage, ChangesetReleasePlan, PackageRelease, VersionedRelease } from './changesets.ts';
 import type { GitRunner } from './git.ts';
 import { ReleaseRepository } from './release-repository.ts';
 export interface ChangesetRepository {
     cwd: string;
     configFile?: string;
+    /** Single-project fallback settings, used only without a release config. */
+    singleProject?: SingleProjectOptions;
     /** Tag format that replaces the tagFormat of the config. */
     tagFormat?: string;
 }
@@ -99,6 +102,7 @@ export interface ChangesetStatusResult {
 export declare class ChangesetRelease {
     readonly cwd: string;
     readonly configFile: string | undefined;
+    readonly singleProject: SingleProjectOptions | undefined;
     readonly tagFormat: string | undefined;
     readonly repository: ReleaseRepository;
     /**
@@ -109,7 +113,7 @@ export declare 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.
      */
     getPlan(): Promise<ChangesetReleasePlan | undefined>;
     /**
@@ -200,7 +204,7 @@ export declare 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.
      */
     private loadContext;
@@ -218,6 +222,8 @@ export declare class ChangesetRelease {
      * @throws {ValidationError} Without a config.
      */
     private requireConfig;
+    /** Load an explicit/discovered config, otherwise resolve one root project. */
+    private loadConfig;
     /**
      * Get the directory of the changeset files.
      *
@@ -230,7 +236,7 @@ export declare 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 declare function getChangesetReleasePlan(input: ChangesetRepository): Promise<ChangesetReleasePlan | undefined>;
 /**

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,12 @@ export declare function formatGitHubOutputs(result: unknown): string;
  * Results of the commands that can be run with execute(), by command name.
  */
 export interface CommandResults {
+    'i18n-mo': import('./i18n/compile.ts').CompileTranslationsResult;
+    'i18n-json': import('./i18n/compile.ts').CompileTranslationsResult;
+    'i18n-php': import('./i18n/compile.ts').CompileTranslationsResult;
+    'i18n-pot': import('./commands/i18n.ts').I18nCommandResult;
+    'i18n-audit': import('./commands/i18n.ts').I18nCommandResult;
+    build: import('./commands/build.ts').BuildResult;
     'deploy-svn': import('./commands/deploy-svn.ts').DeploySvnResult;
     zip: ZipResult;
     checksums: ChecksumsResult;

package/dist/cli.js

@@ -1,7 +1,13 @@
 import { randomUUID } from 'node:crypto';
 import { appendFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';
+import i18nMo from "./commands/i18n-mo.js";
+import i18nJson from "./commands/i18n-json.js";
+import i18nPhp from "./commands/i18n-php.js";
+import i18nPot from "./commands/i18n-pot.js";
+import i18nAudit from "./commands/i18n-audit.js";
 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 +28,12 @@ export const EXIT_SUCCESS = 0;
 export const EXIT_FAILURE = 1;
 export const EXIT_INVALID = 2;
 export const commands = [
+    i18nMo,
+    i18nJson,
+    i18nPhp,
+    i18nPot,
+    i18nAudit,
+    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;
+};