@wpelevator/wp-release 0.5.0 → 0.6.1

package/dist/changeset-release.js

@@ -0,0 +1,835 @@
+import { randomUUID } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { access, mkdir, readdir, readFile, rm, writeFile, } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { loadChangesetConfig } from "./changeset-config.js";
+import { findMainPluginFile } from "./package-meta.js";
+import { findConstantValues } from "./version-check.js";
+import { getChangesetBump, getNextVersion, parseChangeset, } from "./changesets.js";
+import { ValidationError } from "./errors.js";
+const execFileAsync = promisify(execFile);
+/**
+ * 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.
+ */
+export async function getChangesetReleasePlan(input) {
+    const context = await getReleaseContext(input);
+    return context?.plan;
+}
+async function getReleaseContext(input) {
+    const loaded = await loadChangesetConfig(input);
+    if (!loaded) {
+        return undefined;
+    }
+    const config = loaded.config;
+    const packages = await discoverPackages(input.cwd, config);
+    const changesets = await readChangesets(input.cwd, config);
+    const releases = [];
+    packages.forEach((pkg) => {
+        const bump = getChangesetBump(changesets, pkg.name);
+        if (bump) {
+            const packageChangesets = changesets.filter((changeset) => Object.hasOwn(changeset.packages, pkg.name));
+            const nextVersion = config.nextVersion
+                ? config.nextVersion({
+                    package: pkg,
+                    bump,
+                    currentVersion: pkg.currentVersion,
+                    changesets: packageChangesets,
+                })
+                : getNextVersion(pkg.currentVersion, bump);
+            if ('string' !== typeof nextVersion || !nextVersion.trim()) {
+                throw new ValidationError(`The nextVersion strategy returned an empty version for package "${pkg.name}".`);
+            }
+            releases.push({
+                package: pkg,
+                bump,
+                currentVersion: pkg.currentVersion,
+                nextVersion,
+                changesets: packageChangesets,
+            });
+        }
+    });
+    changesets.forEach((changeset) => {
+        Object.keys(changeset.packages).forEach((name) => {
+            if (!packages.some((pkg) => pkg.name === name)) {
+                throw new ValidationError(`Changeset ${changeset.fileName} refers to unknown package "${name}".`);
+            }
+        });
+    });
+    return { config, packages, plan: { changesets, releases } };
+}
+/**
+ * Create a Changesets-compatible Markdown file.
+ *
+ * @param input Repository, packages and summary.
+ * @return Created file path.
+ */
+export async function addChangeset(input) {
+    const loaded = await requireConfig(input);
+    const packages = await discoverPackages(input.cwd, loaded.config);
+    Object.keys(input.packages).forEach((name) => {
+        if (!packages.some((pkg) => pkg.name === name)) {
+            throw new ValidationError(`Unknown package "${name}".`);
+        }
+    });
+    const directory = path.resolve(input.cwd, loaded.config.changesets ?? '.changeset');
+    await mkdir(directory, { recursive: true });
+    const fileName = `${input.name ?? randomUUID().slice(0, 8)}.md`;
+    const file = path.join(directory, fileName);
+    let exists = false;
+    try {
+        await access(file);
+        exists = true;
+    }
+    catch (error) {
+        if ('ENOENT' !== error.code) {
+            throw error;
+        }
+    }
+    if (exists) {
+        throw new ValidationError(`Changeset ${fileName} already exists.`);
+    }
+    const entries = Object.entries(input.packages)
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([name, bump]) => `${JSON.stringify(name)}: ${bump}`)
+        .join('\n');
+    await writeFile(file, `---\n${entries}\n---\n\n${input.summary.trim()}\n`);
+    return file;
+}
+/**
+ * Apply pending package versions and changelogs.
+ *
+ * @param input Repository and versioning options.
+ * @return Planned releases and whether files were changed.
+ */
+export async function versionChangesets(input) {
+    const context = await getReleaseContext(input);
+    if (!context) {
+        throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
+    }
+    const { config, packages, plan: releasePlan } = context;
+    const date = input.date ?? new Date().toISOString().slice(0, 10);
+    if (!input.dryRun) {
+        const journal = new Map();
+        try {
+            for (const release of releasePlan.releases) {
+                const configured = packages.find((pkg) => pkg.name === release.package.name);
+                if (!configured) {
+                    throw new ValidationError(`Unknown package "${release.package.name}".`);
+                }
+                for (const target of configured.versionConfig.to) {
+                    await writeVersion(configured.directory, target, release.nextVersion, journal);
+                }
+                await verifyVersionTargets(input.cwd, configured, release.nextVersion);
+                await prependChangelog(configured.directory, release, date, config.readmeChangelog ?? false, config.changelogInsertAfter, journal);
+            }
+            const changesetDirectory = path.resolve(input.cwd, config.changesets ?? '.changeset');
+            for (const changeset of releasePlan.changesets) {
+                const file = path.join(changesetDirectory, changeset.fileName);
+                await rememberFile(journal, file);
+                await rm(file);
+            }
+        }
+        catch (error) {
+            const rollbackErrors = await restoreFileJournal(journal);
+            if (rollbackErrors.length) {
+                throw new AggregateError([error, ...rollbackErrors], 'Changeset versioning failed and one or more file changes could not be rolled back.');
+            }
+            throw error;
+        }
+    }
+    return {
+        ...releasePlan,
+        date,
+        changed: !input.dryRun && releasePlan.changesets.length > 0,
+    };
+}
+/**
+ * Create missing release tags, optionally pushing them to the configured remote.
+ *
+ * @param input Repository and tag options.
+ * @return Per-package tags and release notes.
+ */
+export async function tagChangesets(input) {
+    if (input.githubRelease && !input.push) {
+        throw new ValidationError('GitHub Releases require pushing the tags.');
+    }
+    if (input.untagged && input.push) {
+        throw new ValidationError('Listing untagged releases cannot be combined with pushing tags.');
+    }
+    const context = await getReleaseContext(input);
+    if (!context) {
+        throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
+    }
+    const packages = input.since
+        ? (await changedPackagesSince(input.cwd, context.packages, input.since)).packages
+        : context.packages;
+    const results = [];
+    const dryRun = input.dryRun || input.untagged;
+    const tagFormat = context.config.tagFormat ?? '{path}/{version}';
+    for (const pkg of packages) {
+        const version = 'git-tag' === pkg.versionConfig.from.kind
+            ? await getLatestChangelogVersion(pkg.directory, pkg.currentVersion)
+            : pkg.currentVersion;
+        const tag = formatTag(tagFormat, pkg, version);
+        const exists = await gitTagExists(input.cwd, tag);
+        const notes = await readReleaseNotes(pkg.directory, version);
+        if (!exists && !dryRun) {
+            await git(input.cwd, ['tag', tag]);
+        }
+        results.push({
+            package: pkg.name,
+            version,
+            tag,
+            exists,
+            created: !exists && !dryRun,
+            notes,
+        });
+    }
+    // Push one tag at a time because GitHub doesn't create push events for
+    // tags when more than three are pushed at once.
+    if (input.push && !dryRun) {
+        for (const item of results.filter((result) => result.created)) {
+            await git(input.cwd, ['push', 'origin', item.tag]);
+        }
+    }
+    if (input.githubRelease && !dryRun) {
+        for (const release of results) {
+            await createGitHubRelease(input.cwd, release);
+        }
+    }
+    return {
+        tags: input.untagged
+            ? results.filter((result) => !result.exists)
+            : results,
+    };
+}
+async function createGitHubRelease(cwd, release) {
+    try {
+        await execFileAsync('gh', ['release', 'view', release.tag], {
+            cwd,
+        });
+    }
+    catch {
+        try {
+            await execFileAsync('gh', [
+                'release',
+                'create',
+                release.tag,
+                '--title',
+                `${release.package}@${release.version}`,
+                '--notes',
+                release.notes,
+            ], { cwd });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new ValidationError(`Could not create GitHub Release for ${release.tag}: ${message}`);
+        }
+    }
+}
+/**
+ * Check whether changed files belong to packages without a changeset.
+ *
+ * @param input Repository and base git ref.
+ * @return Changed packages and missing changeset identifiers.
+ */
+export async function getChangesetStatus(input) {
+    const context = await getReleaseContext(input);
+    if (!context) {
+        throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
+    }
+    const { plan } = context;
+    const { changesets, releases } = plan;
+    const since = input.since ??
+        (context.config.baseBranch
+            ? `origin/${context.config.baseBranch}`
+            : undefined);
+    const changed = since
+        ? await changedPackagesSince(input.cwd, context.packages, since)
+        : { packages: [], filesByPackage: {} };
+    const changedPackages = changed.packages.map((pkg) => pkg.name);
+    const changesetsInDiff = since
+        ? await readChangesetsSince(input.cwd, context.config, changesets, since)
+        : [];
+    const hasEmptyChangeset = changesetsInDiff.some((changeset) => 0 === Object.keys(changeset.packages).length);
+    const missingChangesets = hasEmptyChangeset
+        ? []
+        : changedPackages.filter((name) => !changesetsInDiff.some((item) => Object.hasOwn(item.packages, name)));
+    return {
+        changesets,
+        releases,
+        changedPackages,
+        changedPackageFiles: changed.filesByPackage,
+        missingChangesets,
+    };
+}
+async function requireConfig(input) {
+    const loaded = await loadChangesetConfig(input);
+    if (!loaded) {
+        throw new ValidationError('No wp-release config found. Add wp-release.config.js or pass --config <path>.');
+    }
+    return loaded;
+}
+async function readChangesets(cwd, config) {
+    const directory = path.resolve(cwd, config.changesets ?? '.changeset');
+    let entries;
+    try {
+        entries = await readdir(directory);
+    }
+    catch (error) {
+        if ('ENOENT' === error.code) {
+            return [];
+        }
+        throw error;
+    }
+    return Promise.all(entries
+        .filter((name) => name.endsWith('.md') && !name.startsWith('README'))
+        .sort()
+        .map(async (name) => parseChangeset(await readFile(path.join(directory, name), 'utf8'), name)));
+}
+async function readChangesetsSince(cwd, config, changesets, since) {
+    const directory = path.resolve(cwd, config.changesets ?? '.changeset');
+    const relativeDirectory = path
+        .relative(cwd, directory)
+        .split(path.sep)
+        .join('/');
+    const output = await git(cwd, [
+        'diff',
+        '--name-only',
+        '--diff-filter=ACMR',
+        `${since}...HEAD`,
+        '--',
+        relativeDirectory,
+    ]);
+    const changedFiles = new Set(output.trim().split(/\r?\n/).filter(Boolean));
+    return changesets.filter((changeset) => changedFiles.has(path.posix.join(relativeDirectory, changeset.fileName)));
+}
+async function discoverPackages(cwd, config) {
+    const root = path.resolve(cwd, config.root ?? '.');
+    const packages = [];
+    const hasRecursiveGlob = config.packages.some((item) => item.glob.split('/').includes('**'));
+    const directories = await findDirectories(root, '', hasRecursiveGlob
+        ? Infinity
+        : Math.max(1, ...config.packages.map((item) => item.glob.split('/').length + 2)));
+    for (const group of config.packages) {
+        const matcher = globRegExp(group.glob);
+        const candidates = matcher.test('.')
+            ? ['.', ...directories]
+            : directories;
+        const matches = candidates
+            .filter((item) => matcher.test(item) &&
+            !(group.exclude ?? []).some((excluded) => globRegExp(excluded).test(item)))
+            .sort();
+        if (!matches.length) {
+            throw new ValidationError(`Package glob "${group.glob}" did not match any directories under ${root}.`);
+        }
+        for (const relativePath of matches) {
+            const directory = path.join(root, relativePath);
+            const name = await packageName(directory, relativePath, group.idFrom ?? 'path');
+            const currentVersion = await readVersion(cwd, directory, group.version.from, relativePath, group.tagType);
+            if (packages.some((pkg) => pkg.name === name)) {
+                throw new ValidationError(`Package identifier "${name}" is configured more than once.`);
+            }
+            packages.push({
+                name,
+                directory,
+                path: relativePath,
+                type: packageType(group),
+                currentVersion,
+                group,
+                versionConfig: group.version,
+            });
+        }
+    }
+    return packages;
+}
+async function findDirectories(root, prefix = '', maxDepth = 5) {
+    let entries;
+    try {
+        entries = await readdir(path.join(root, prefix), {
+            withFileTypes: true,
+        });
+    }
+    catch (error) {
+        if ('ENOENT' === error.code) {
+            return [];
+        }
+        throw error;
+    }
+    const directories = entries.filter((item) => item.isDirectory() &&
+        !['.git', 'node_modules', 'vendor', 'dist'].includes(item.name));
+    if (prefix.split(path.sep).filter(Boolean).length >= maxDepth) {
+        return directories.map((item) => path.join(prefix, item.name));
+    }
+    const children = await Promise.all(directories.map((item) => findDirectories(root, path.join(prefix, item.name), maxDepth)));
+    return [
+        ...directories.map((item) => path.join(prefix, item.name)),
+        ...children.flat(),
+    ];
+}
+function globRegExp(glob) {
+    const escaped = glob
+        .split('/')
+        .map((part) => {
+        if ('**' === part) {
+            return '.*';
+        }
+        return part
+            .replaceAll(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replaceAll('*', '[^/]*')
+            .replaceAll('?', '[^/]');
+    })
+        .join('/');
+    return new RegExp(`^${escaped}$`);
+}
+async function packageName(directory, relativePath, idFrom) {
+    if ('path' === idFrom) {
+        if ('.' === relativePath) {
+            return path.basename(directory);
+        }
+        return relativePath.split(path.sep).join('/');
+    }
+    const [file, field] = idFrom.split('#');
+    if (!file || !field) {
+        throw new ValidationError(`Invalid package identifier source "${idFrom}".`);
+    }
+    const manifest = await readJson(path.join(directory, file));
+    const name = manifest[field];
+    if ('string' !== typeof name || !name.trim()) {
+        throw new ValidationError(`Expected ${file}#${field} in ${directory}.`);
+    }
+    return name;
+}
+async function readVersion(cwd, directory, descriptor, relativePath, tagType) {
+    if ('package-json' === descriptor.kind ||
+        'composer-json' === descriptor.kind) {
+        const manifest = await readJson(path.join(directory, descriptor.file));
+        const version = manifest[descriptor.field];
+        if ('string' === typeof version && version.trim()) {
+            return version;
+        }
+        throw new ValidationError(`Missing ${descriptor.file}#${descriptor.field} in ${directory}.`);
+    }
+    if ('git-tag' === descriptor.kind) {
+        const pattern = descriptor.pattern ?? '{path}/{version}';
+        const tagsOutput = await git(cwd, [
+            'tag',
+            '--list',
+            `${formatTemplatePrefix(pattern, relativePath, tagType)}*`,
+        ]);
+        const tags = tagsOutput.trim().split(/\r?\n/).filter(Boolean);
+        const versions = tags
+            .map((tag) => tag.match(/(?:^|\/|v)(\d+\.\d+\.\d+)$/)?.[1])
+            .filter((item) => Boolean(item));
+        versions.sort((a, b) => compareVersions(b, a));
+        if (versions[0]) {
+            return versions[0];
+        }
+        throw new ValidationError(`No git tag matches ${pattern} for ${relativePath}.`);
+    }
+    if ('php-constant' === descriptor.kind) {
+        const file = path.join(directory, descriptor.file);
+        const contents = await readFile(file, 'utf8');
+        const versions = findConstantValues(contents, descriptor.constant);
+        if (versions[0]) {
+            return versions[0];
+        }
+        throw new ValidationError(`Missing PHP constant ${descriptor.constant} in ${file}.`);
+    }
+    const file = path.join(directory, await getVersionFile(directory, descriptor.kind, descriptor.file));
+    const contents = await readFile(file, 'utf8');
+    const label = 'wordpress-stable-tag' === descriptor.kind ? 'Stable tag' : 'Version';
+    const match = new RegExp(`^\\s*\\*?\\s*${label}:\\s*([^\\r\\n]+)`, 'im').exec(contents);
+    if (!match) {
+        throw new ValidationError(`Missing ${label} header in ${file}.`);
+    }
+    return match[1]?.trim() ?? '';
+}
+async function writeVersion(directory, descriptor, version, journal) {
+    if ('package-json' === descriptor.kind ||
+        'composer-json' === descriptor.kind) {
+        const file = path.join(directory, descriptor.file);
+        const contents = await readFile(file, 'utf8');
+        const manifest = JSON.parse(contents);
+        if ('composer-json' === descriptor.kind &&
+            descriptor.ifPresent &&
+            !Object.hasOwn(manifest, descriptor.field)) {
+            return;
+        }
+        manifest[descriptor.field] = version;
+        await rememberFile(journal, file);
+        await writeFile(file, `${JSON.stringify(manifest, null, '\t')}\n`);
+        return;
+    }
+    if ('php-constant' === descriptor.kind) {
+        const file = path.join(directory, descriptor.file);
+        const contents = await readFile(file, 'utf8');
+        const constant = escapeRegExp(descriptor.constant);
+        const definePattern = new RegExp(`(\\bdefine\\s*\\(\\s*(['"])${constant}\\2\\s*,\\s*)(['"])(.*?)\\3`, 'g');
+        const declarationPattern = new RegExp(`(\\bconst\\s+${constant}\\s*=\\s*)(['"])(.*?)\\2`, 'g');
+        const updated = contents
+            .replace(definePattern, (_match, prefix, _nameQuote, quote) => `${prefix}${quote}${version}${quote}`)
+            .replace(declarationPattern, (_match, prefix, quote) => `${prefix}${quote}${version}${quote}`);
+        if (updated === contents) {
+            throw new ValidationError(`Missing PHP constant ${descriptor.constant} in ${file}.`);
+        }
+        await rememberFile(journal, file);
+        await writeFile(file, updated);
+        return;
+    }
+    if ('wordpress-stable-tag' === descriptor.kind &&
+        descriptor.ifPresent &&
+        !(await versionFileExists(directory, descriptor.kind, descriptor.file))) {
+        return;
+    }
+    const file = path.join(directory, await getVersionFile(directory, descriptor.kind, descriptor.file));
+    const contents = await readFile(file, 'utf8');
+    const label = 'wordpress-stable-tag' === descriptor.kind ? 'Stable tag' : 'Version';
+    const expression = new RegExp(`(^\\s*\\*?\\s*${label}:\\s*)[^\\r\\n]+`, 'im');
+    if (!expression.test(contents)) {
+        throw new ValidationError(`Missing ${label} header in ${file}.`);
+    }
+    await rememberFile(journal, file);
+    await writeFile(file, contents.replace(expression, `$1${version}`));
+}
+async function getVersionFile(directory, kind, configuredFile) {
+    if (configuredFile) {
+        return configuredFile;
+    }
+    if ('wordpress-plugin-header' === kind) {
+        const file = await findMainPluginFile({ dir: directory });
+        if (file) {
+            return file;
+        }
+        throw new ValidationError(`Could not find a plugin header file in ${directory}.`);
+    }
+    if ('wordpress-stable-tag' === kind) {
+        for (const file of ['readme.txt', 'readme.md']) {
+            try {
+                await access(path.join(directory, file));
+                return file;
+            }
+            catch {
+                // Try the next WordPress readme filename.
+            }
+        }
+        throw new ValidationError(`Could not find readme.txt or readme.md in ${directory}.`);
+    }
+    return 'style.css';
+}
+async function versionFileExists(directory, kind, configuredFile) {
+    if (configuredFile) {
+        try {
+            await access(path.join(directory, configuredFile));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    if ('wordpress-stable-tag' === kind) {
+        const files = await Promise.all(['readme.txt', 'readme.md'].map(async (file) => {
+            try {
+                await access(path.join(directory, file));
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }));
+        return files.some(Boolean);
+    }
+    return true;
+}
+async function prependChangelog(directory, release, date, readmeChangelog, changelogInsertAfter, journal) {
+    const summaries = release.changesets
+        .map((item) => item.summary.trim())
+        .filter(Boolean);
+    const section = `## ${release.nextVersion} (${date})\n\n${summaries
+        .map((item) => `- ${item.replaceAll(/\r?\n/g, '\n  ')}`)
+        .join('\n')}\n\n`;
+    const changelog = path.join(directory, 'CHANGELOG.md');
+    let previous = '';
+    try {
+        previous = await readFile(changelog, 'utf8');
+    }
+    catch (error) {
+        if ('ENOENT' !== error.code) {
+            throw error;
+        }
+    }
+    const releaseHeading = new RegExp(`^## ${escapeRegExp(release.nextVersion)} \\(`, 'm');
+    if (!releaseHeading.test(previous)) {
+        await rememberFile(journal, changelog);
+        if (undefined !== changelogInsertAfter) {
+            await writeFile(changelog, insertAfterMarker(previous, changelogInsertAfter, section, changelog));
+        }
+        else {
+            const versionHeading = /^##[ \t]+v?\d+(?:\.\d+){1,2}(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?(?:[ \t]+.*)?$/m.exec(previous);
+            const heading = /^#[ \t]+[^\r\n]+[ \t]*$/m.exec(previous);
+            const insertion = versionHeading ?? heading;
+            if (insertion) {
+                const before = previous
+                    .slice(0, insertion.index)
+                    .replace(/(?:\r?\n)*$/, '');
+                const after = previous.slice(insertion.index);
+                const prefix = before ? `${before}\n\n` : '';
+                await writeFile(changelog, `${prefix}${section}${after}`);
+            }
+            else {
+                await writeFile(changelog, `${section}${previous}`);
+            }
+        }
+    }
+    if (readmeChangelog) {
+        const readme = ['readme.txt', 'readme.md'].map((name) => path.join(directory, name));
+        let readmeUpdated = false;
+        let readmeFound = false;
+        let readmeMarkerFound = false;
+        let readmeAlreadyVersioned = false;
+        for (const file of readme) {
+            try {
+                const contents = await readFile(file, 'utf8');
+                readmeFound = true;
+                const defaultHeading = undefined === changelogInsertAfter
+                    ? /^==\s*Changelog\s*==\s*$/im.exec(contents)?.[0]
+                    : undefined;
+                const insertionMarker = changelogInsertAfter ?? defaultHeading;
+                readmeMarkerFound ||=
+                    undefined !== insertionMarker &&
+                        contents.includes(insertionMarker);
+                const alreadyVersioned = new RegExp(`^=\\s*${escapeRegExp(release.nextVersion)}\\s*=$`, 'm').test(contents);
+                readmeAlreadyVersioned ||= alreadyVersioned;
+                if (insertionMarker &&
+                    !alreadyVersioned &&
+                    !readmeUpdated &&
+                    contents.includes(insertionMarker)) {
+                    const readmeSection = `\n\n= ${release.nextVersion} =\n\n${summaries
+                        .map((item) => `* ${item.replaceAll(/\r?\n/g, '\n  ')}`)
+                        .join('\n')}\n\n`;
+                    await rememberFile(journal, file);
+                    await writeFile(file, insertAfterMarker(contents, insertionMarker, readmeSection.trimStart(), file));
+                    readmeUpdated = true;
+                }
+            }
+            catch (error) {
+                if ('ENOENT' !== error.code) {
+                    throw error;
+                }
+            }
+        }
+        if (changelogInsertAfter &&
+            readmeFound &&
+            !readmeMarkerFound &&
+            !readmeAlreadyVersioned) {
+            throw new ValidationError(`Changelog insertion marker "${changelogInsertAfter}" was not found in a plugin readme in ${directory}.`);
+        }
+    }
+}
+function insertAfterMarker(contents, marker, section, file) {
+    const index = contents.indexOf(marker);
+    if (-1 === index) {
+        throw new ValidationError(`Changelog insertion marker "${marker}" was not found in ${file}.`);
+    }
+    const markerEnd = index + marker.length;
+    const after = contents
+        .slice(markerEnd)
+        .replace(/^(?:[ \t]*\r?\n)+/, '');
+    const lineEnding = contents.includes('\r\n') ? '\r\n' : '\n';
+    return `${contents.slice(0, markerEnd)}${lineEnding}${lineEnding}${section.replaceAll('\n', lineEnding)}${after}`;
+}
+async function changedPackagesSince(cwd, packages, since) {
+    const output = await git(cwd, [
+        'diff',
+        '--name-only',
+        `${since}...HEAD`,
+    ]);
+    const changedFiles = output.trim().split(/\r?\n/).filter(Boolean);
+    const filesByPackage = {};
+    const changed = packages.filter((pkg) => {
+        const packageFromRepo = path
+            .relative(cwd, pkg.directory)
+            .split(path.sep)
+            .join('/');
+        const matchingFiles = '.' === packageFromRepo
+            ? changedFiles
+            : changedFiles.filter((file) => file === packageFromRepo ||
+                file.startsWith(`${packageFromRepo}/`));
+        if (matchingFiles.length) {
+            filesByPackage[pkg.name] = matchingFiles;
+        }
+        return matchingFiles.length > 0;
+    });
+    return { packages: changed, filesByPackage };
+}
+function formatTag(format, pkg, version) {
+    const type = pkg.group.tagType ?? defaultTagType(pkg.path, pkg.type);
+    return format
+        .replaceAll('{name}', pkg.name)
+        .replaceAll('{slug}', '.' === pkg.path
+        ? path.basename(pkg.directory)
+        : path.basename(pkg.path))
+        .replaceAll('{path}', pkg.path)
+        .replaceAll('{type}', type)
+        .replaceAll('{version}', version);
+}
+function defaultTagType(packagePath, type) {
+    if ('.' === packagePath && type) {
+        return type;
+    }
+    const first = packagePath.split('/')[0] ?? 'package';
+    const irregular = {
+        actions: 'action',
+        plugins: 'plugin',
+        themes: 'theme',
+        php: 'php',
+        js: 'js',
+    };
+    return irregular[first] ?? first.replace(/s$/, '');
+}
+function formatTemplatePrefix(pattern, packagePath, tagType) {
+    return pattern
+        .replaceAll('{path}', packagePath)
+        .replaceAll('{type}', tagType ?? defaultTagType(packagePath))
+        .replaceAll('{name}', packagePath.split('/').at(-1) ?? packagePath)
+        .replaceAll('{slug}', packagePath.split('/').at(-1) ?? packagePath)
+        .replaceAll('{version}', '');
+}
+async function verifyVersionTargets(cwd, pkg, expected) {
+    for (const target of pkg.versionConfig.to) {
+        let actual;
+        if ('composer-json' === target.kind &&
+            target.ifPresent &&
+            !Object.hasOwn(await readJson(path.join(pkg.directory, target.file)), target.field)) {
+            actual = undefined;
+        }
+        else if ('wordpress-stable-tag' === target.kind &&
+            target.ifPresent &&
+            !(await versionFileExists(pkg.directory, target.kind, target.file))) {
+            actual = undefined;
+        }
+        else {
+            actual = await readVersion(cwd, pkg.directory, target, pkg.path, pkg.group.tagType);
+        }
+        if (undefined !== actual && actual !== expected) {
+            throw new ValidationError(`Version mismatch for ${pkg.name}: expected ${expected}, found ${actual}.`);
+        }
+    }
+}
+async function gitTagExists(cwd, tag) {
+    const result = await git(cwd, ['tag', '--list', tag]);
+    return result.trim() === tag;
+}
+async function git(cwd, args) {
+    const directory = path.resolve(cwd);
+    try {
+        const { stdout } = await execFileAsync('git', ['-c', `safe.directory=${directory}`, ...args], { cwd: directory });
+        return stdout;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ValidationError(`Git command failed (${args.join(' ')}): ${message}`);
+    }
+}
+async function readReleaseNotes(directory, version) {
+    let contents = '';
+    try {
+        contents = await readFile(path.join(directory, 'CHANGELOG.md'), 'utf8');
+    }
+    catch (error) {
+        if ('ENOENT' !== error.code) {
+            throw error;
+        }
+    }
+    const lines = contents.split(/\r?\n/);
+    const headingIndex = lines.findIndex((line) => new RegExp(`^##\\s+${escapeRegExp(version)}(?:\\s|$)`).test(line));
+    if (-1 === headingIndex) {
+        return '';
+    }
+    const followingHeading = lines.findIndex((line, index) => index > headingIndex && /^##\s/.test(line));
+    const end = -1 === followingHeading ? lines.length : followingHeading;
+    return lines
+        .slice(headingIndex + 1, end)
+        .join('\n')
+        .trim();
+}
+async function getLatestChangelogVersion(directory, fallback) {
+    try {
+        const contents = await readFile(path.join(directory, 'CHANGELOG.md'), 'utf8');
+        const match = /^##\s+(\d+\.\d+\.\d+)(?:\s|$)/m.exec(contents);
+        return match?.[1] ?? fallback;
+    }
+    catch (error) {
+        if ('ENOENT' === error.code) {
+            return fallback;
+        }
+        throw error;
+    }
+}
+function escapeRegExp(value) {
+    return value.replaceAll(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+async function rememberFile(journal, file) {
+    if (journal.has(file)) {
+        return;
+    }
+    try {
+        journal.set(file, await readFile(file, 'utf8'));
+    }
+    catch (error) {
+        if ('ENOENT' !== error.code) {
+            throw error;
+        }
+        journal.set(file, undefined);
+    }
+}
+async function restoreFileJournal(journal) {
+    const errors = [];
+    for (const [file, contents] of [...journal.entries()].reverse()) {
+        try {
+            if (undefined === contents) {
+                await rm(file, { force: true });
+            }
+            else {
+                await writeFile(file, contents);
+            }
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    return errors;
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ValidationError(`Could not read JSON manifest ${file}: ${message}`);
+    }
+}
+function packageType(group) {
+    const kind = group.version.from.kind;
+    if ('wordpress-plugin-header' === kind) {
+        return 'plugin';
+    }
+    if ('wordpress-theme-header' === kind) {
+        return 'theme';
+    }
+    if ('package-json' === kind) {
+        return 'npm';
+    }
+    return 'other';
+}
+function compareVersions(left, right) {
+    const a = left.split('.').map(Number);
+    const b = right.split('.').map(Number);
+    return ((a[0] ?? 0) - (b[0] ?? 0) ||
+        (a[1] ?? 0) - (b[1] ?? 0) ||
+        (a[2] ?? 0) - (b[2] ?? 0));
+}