@ckeditor/ckeditor5-dev-changelog 50.1.0

package/dist/index.js

@@ -0,0 +1,1284 @@
+import chalk from 'chalk';
+import { parse, isValid, format } from 'date-fns';
+import { workspaces, npm, tools } from '@ckeditor/ckeditor5-dev-utils';
+import upath from 'upath';
+import fs$1 from 'fs-extra';
+import fs from 'fs';
+import semver from 'semver';
+import inquirer from 'inquirer';
+import { glob } from 'glob';
+import matter from 'gray-matter';
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+const CHANGELOG_FILE = 'CHANGELOG.md';
+const CHANGELOG_HEADER = 'Changelog\n=========';
+const NPM_URL = 'https://www.npmjs.com/package';
+const VERSIONING_POLICY_URL = 'https://ckeditor.com/docs/ckeditor5/latest/framework/guides/support/versioning-policy.html';
+const CHANGESET_DIRECTORY = '.changelog';
+upath.join(import.meta.dirname, '../template/template.md');
+const SECTIONS = {
+    major: {
+        title: `MAJOR BREAKING CHANGES [ℹ️](${VERSIONING_POLICY_URL}#major-and-minor-breaking-changes)`,
+        titleInLogs: 'MAJOR BREAKING CHANGES'
+    },
+    minor: {
+        title: `MINOR BREAKING CHANGES [ℹ️](${VERSIONING_POLICY_URL}#major-and-minor-breaking-changes)`,
+        titleInLogs: 'MINOR BREAKING CHANGES'
+    },
+    breaking: { title: 'BREAKING CHANGES' },
+    feature: { title: 'Features' },
+    fix: { title: 'Bug fixes' },
+    other: { title: 'Other changes' },
+    warning: {
+        title: 'Incorrect values',
+        excludeInChangelog: true
+    },
+    invalid: {
+        title: 'Invalid files',
+        excludeInChangelog: true
+    }
+};
+const ISSUE_SLUG_PATTERN = /^(?<owner>[a-z0-9.-]+)\/(?<repository>[a-z0-9.-]+)#(?<number>\d+)$/;
+const ISSUE_PATTERN = /^\d+$/;
+const ISSUE_URL_PATTERN = /^(?<base>https:\/\/github\.com)\/(?<owner>[a-z0-9.-]+)\/(?<repository>[a-z0-9.-]+)\/issues\/(?<number>\d+)$/;
+const TYPES = [
+    { name: 'Feature' },
+    { name: 'Other' },
+    { name: 'Fix' },
+    { name: 'Major breaking change' },
+    { name: 'Minor breaking change' },
+    { name: 'Breaking change' }
+];
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * This function enhances changelog entries by linking contributor usernames to their GitHub profiles.
+ *
+ * It searches for occurrences of GitHub-style mentions (e.g., @username) in the given comment string
+ * and transforms them into Markdown links pointing to the corresponding GitHub user page.
+ */
+function linkToGitHubUser(comment) {
+    return comment.replace(/(^|[\s(])@([\w-]+)(?![/\w-])/ig, (_, charBefore, nickName) => {
+        return `${charBefore}[@${nickName}](https://github.com/${nickName})`;
+    });
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Validates a changelog entry against expected types, scopes, and issue references.
+ *
+ * It checks if the type is valid and consistent with single or multi-package modes,
+ * verifies scopes against known package names, and ensures issue references are correctly formatted.
+ *
+ * Returns whether the entry is valid along with a validated version including any validation messages.
+ */
+function validateEntry(entry, packagesNames, singlePackage) {
+    const noScopePackagesNames = packagesNames.map(packageName => packageName.replace(/@.*\//, ''));
+    const data = entry.data;
+    const validations = [];
+    let isValid = true;
+    const allowedTypesArray = TYPES.map(({ name }) => name);
+    const allowedTypesList = getAllowedTypesList();
+    if (typeof data.type === 'undefined') {
+        validations.push(`Provide a type with one of the values: ${allowedTypesList} (case insensitive).`);
+        isValid = false;
+    }
+    else if (!allowedTypesArray.includes(data.type)) {
+        validations.push(`Type is required and should be one of: ${allowedTypesList} (case insensitive).`);
+        isValid = false;
+    }
+    if (singlePackage && ['Major breaking change', 'Minor breaking change'].includes(data.type)) {
+        validations.push(`Breaking change "${data.type}" should be generic: "Breaking change", for a single package mode (case insensitive).`);
+        isValid = false;
+    }
+    if (!singlePackage && data.type === 'Breaking change') {
+        validations.push(`Breaking change "${data.type}" should be one of: "Minor breaking change", "Major breaking change" ` +
+            'for a monorepo (case insensitive).');
+        isValid = false;
+    }
+    const scopeValidated = [];
+    if (singlePackage) {
+        // Skip scope validation for single package mode
+        scopeValidated.push(...data.scope);
+    }
+    else {
+        for (const scopeName of data.scope) {
+            if (!noScopePackagesNames.includes(scopeName)) {
+                validations.push(`Scope "${scopeName}" is not recognized as a valid package in the repository.`);
+            }
+            else {
+                scopeValidated.push(scopeName);
+            }
+        }
+    }
+    data.scope = scopeValidated;
+    const seeValidated = [];
+    for (const see of data.see) {
+        if (!(see.match(ISSUE_PATTERN) || see.match(ISSUE_SLUG_PATTERN) || see.match(ISSUE_URL_PATTERN))) {
+            validations.push([
+                `See "${see}" is not a valid issue reference. Provide either:`,
+                'issue number, repository-slug#id or full issue link URL.'
+            ].join(' '));
+        }
+        else {
+            seeValidated.push(see);
+        }
+    }
+    data.see = seeValidated;
+    const closesValidated = [];
+    for (const closes of data.closes) {
+        if (!(closes.match(ISSUE_PATTERN) || closes.match(ISSUE_SLUG_PATTERN) || closes.match(ISSUE_URL_PATTERN))) {
+            validations.push([
+                `Closes "${closes}" is not a valid issue reference. Provide either:`,
+                'issue number, repository-slug#id or full issue link URL.'
+            ].join(' '));
+        }
+        else {
+            closesValidated.push(closes);
+        }
+    }
+    data.closes = closesValidated;
+    const validatedEntry = {
+        ...entry,
+        data: {
+            ...data,
+            validations,
+            type: data.type
+        }
+    };
+    return { isValid, validatedEntry };
+}
+function getAllowedTypesList() {
+    const formatter = new Intl.ListFormat('en-US', { style: 'long', type: 'disjunction' });
+    const items = TYPES.map(type => `"${type.name}"`);
+    return formatter.format(items);
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * This function categorizes changelog entries based on their types and packages.
+ */
+function groupEntriesBySection(options) {
+    const { files, packagesMetadata, transformScope, isSinglePackage } = options;
+    const packageNames = [...packagesMetadata.keys()];
+    return files.reduce((sections, entry) => {
+        const { validatedEntry, isValid } = validateEntry(entry, packageNames, isSinglePackage);
+        const validatedData = validatedEntry.data;
+        const scope = isSinglePackage ? null : getScopesLinks(validatedData.scope, transformScope);
+        const closes = getIssuesLinks(validatedData.closes, 'Closes', validatedEntry.gitHubUrl);
+        const see = getIssuesLinks(validatedData.see, 'See', validatedEntry.gitHubUrl);
+        const section = getSection({ entry: validatedEntry, isSinglePackage, isValid });
+        const contentWithCommunityCredits = getContentWithCommunityCredits(validatedEntry.content, validatedData.communityCredits);
+        const content = linkToGitHubUser(contentWithCommunityCredits);
+        const [mainContent, ...restContent] = formatContent(content);
+        const changeMessage = getChangeMessage({ restContent, scope, mainContent, entry, see, closes });
+        const newEntry = {
+            message: changeMessage,
+            data: {
+                mainContent,
+                restContent,
+                type: validatedData.type,
+                scope: validatedData.scope,
+                see: validatedData.see.map(see => getIssueLinkObject(see, validatedEntry.gitHubUrl)),
+                closes: validatedData.closes.map(closes => getIssueLinkObject(closes, validatedEntry.gitHubUrl)),
+                validations: validatedData.validations,
+                communityCredits: validatedData.communityCredits
+            },
+            changesetPath: validatedEntry.changesetPath
+        };
+        sections[section].entries.push(newEntry);
+        if (isValid && newEntry.data.validations?.length) {
+            sections.warning.entries.push(newEntry);
+        }
+        return sections;
+    }, getInitialSectionsWithEntries());
+}
+function getChangeMessage({ restContent, scope, mainContent, entry, see, closes }) {
+    const messageFirstLine = [
+        '*',
+        scope ? `**${scope}**:` : null,
+        mainContent,
+        !entry.shouldSkipLinks && see.length ? see : null,
+        !entry.shouldSkipLinks && closes.length ? closes : null
+    ].filter(Boolean).join(' ');
+    if (!restContent || !restContent.length) {
+        return messageFirstLine;
+    }
+    return `${messageFirstLine}\n\n${restContent.map(line => {
+        if (line.length) {
+            return `  ${line}`;
+        }
+        return line;
+    }).join('\n')}`;
+}
+function formatContent(content) {
+    const lines = content.trim()
+        .split('\n')
+        .map(line => line.trimEnd());
+    const mainIndex = lines.findIndex(line => line.trim() !== '');
+    const mainContent = lines.at(mainIndex);
+    let restContent = lines.slice(mainIndex + 1);
+    if (restContent.at(0)?.trim() === '') {
+        restContent = restContent.slice(1);
+    }
+    const cleanedRestContent = restContent.reduce((acc, line) => {
+        if (line.trim() === '') {
+            // Only add empty line if the last item is not already an empty line
+            if (acc.length > 0 && acc.at(-1) !== '') {
+                acc.push('');
+            }
+        }
+        else {
+            acc.push(line);
+        }
+        return acc;
+    }, []);
+    return [mainContent, ...cleanedRestContent];
+}
+function getContentWithCommunityCredits(content, communityCredits) {
+    if (!communityCredits?.length) {
+        return content;
+    }
+    return content.concat(`\n\nThanks to ${communityCredits?.join(', ')}.`);
+}
+function getScopesLinks(scope, transformScope) {
+    return scope
+        .map(scope => transformScope(scope))
+        .map(({ displayName, npmUrl }) => `[${displayName}](${npmUrl})`)
+        .join(', ');
+}
+function getIssueLinkObject(issue, gitHubUrl) {
+    if (issue.match(ISSUE_PATTERN)) {
+        return { displayName: `#${issue}`, link: `${gitHubUrl}/issues/${issue}` };
+    }
+    const differentRepoMatch = issue.match(ISSUE_SLUG_PATTERN);
+    if (differentRepoMatch) {
+        const { owner, repository, number } = differentRepoMatch.groups;
+        return { displayName: issue, link: `https://github.com/${owner}/${repository}/issues/${number}` };
+    }
+    const repoUrlMatch = issue.match(ISSUE_URL_PATTERN);
+    if (repoUrlMatch) {
+        const { owner, repository, number } = repoUrlMatch.groups;
+        return { displayName: `${owner}/${repository}#${number}`, link: issue };
+    }
+    return { displayName: '', link: '' };
+}
+function getIssuesLinks(issues, prefix, gitHubUrl) {
+    if (!issues.length) {
+        return '';
+    }
+    const links = issues.map(String).map(issue => {
+        const { displayName, link } = getIssueLinkObject(issue, gitHubUrl);
+        return `[${displayName}](${link})`;
+    });
+    return `${prefix} ${links.join(', ')}.`;
+}
+function getSection(options) {
+    const { entry, isSinglePackage, isValid } = options;
+    if (!isValid) {
+        return 'invalid';
+    }
+    // If someone tries to use minor/major breaking change in a single package, we simply cast it to a generic breaking change.
+    if (isSinglePackage) {
+        const breakingChangeTypes = ['Minor breaking change', 'Major breaking change', 'Breaking change'];
+        if (breakingChangeTypes.includes(entry.data.type)) {
+            return 'breaking';
+        }
+    }
+    else {
+        if (entry.data.type === 'Minor breaking change') {
+            return 'minor';
+        }
+        if (entry.data.type === 'Major breaking change') {
+            return 'major';
+        }
+    }
+    return entry.data.type.toLowerCase();
+}
+function getInitialSectionsWithEntries() {
+    const sections = structuredClone(SECTIONS);
+    for (const key in sections) {
+        sections[key].entries = [];
+    }
+    return sections;
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * This function provides a consistent logging format for the changelog generation process.
+ *
+ * It logs the given text to the console, optionally indenting it by a specified number of levels.
+ */
+function logInfo(text, { indent } = { indent: 0 }) {
+    console.log(' '.repeat(indent * 3) + text);
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Displays a formatted summary of all changelog entries grouped by sections (e.g., Features, Fixes, Breaking changes).
+ *
+ * This function:
+ * * Lists all non-empty changelog sections with appropriate formatting.
+ * * Differentiates between valid and invalid entries using visual indicators (`+` for valid, `x` for invalid).
+ * * Supports both mono-repository and single package repositories through the `isSinglePackage` flag.
+ * * Applies a transformation to scope names using the `transformScope` callback for a mono-repository setup.
+ * * Outputs a helpful legend for interpreting the entry indicators.
+ */
+function displayChanges(options) {
+    const { sections, isSinglePackage, transformScope } = options;
+    let numberOfEntries = 0;
+    logInfo(`○ ${chalk.cyan('Listing the changes...')}`);
+    const nonEmptySections = Object.entries(sections)
+        .filter(([, section]) => section.entries.length);
+    for (const [sectionName, section] of nonEmptySections) {
+        const color = getTitleColor(sectionName);
+        logInfo('◌ ' + color(chalk.underline(`${section.titleInLogs || section.title}:`)), { indent: 1 });
+        const displayCallback = sectionName === 'invalid' || sectionName === 'warning' ?
+            displayWarningEntry :
+            displayValidEntry;
+        if (sectionName !== 'warning') {
+            numberOfEntries += section.entries.length;
+        }
+        section.entries.forEach(entry => displayCallback(entry, sectionName, isSinglePackage, transformScope));
+        logInfo('');
+    }
+    logInfo('◌ ' + chalk.underline('Legend:'), { indent: 1 });
+    logInfo(`- Entries marked with ${chalk.green('+')} symbol are included in the changelog.`, { indent: 2 });
+    logInfo('- Entries marked with ' + chalk.yellow('x') + ' symbol include invalid references (see and/or closes) ' +
+        'or scope definitions. Please ensure that:', { indent: 2 });
+    logInfo('* Reference entries match one of the following formats:', { indent: 3 });
+    logInfo('1. An issue number (e.g., 1000)', { indent: 4 });
+    logInfo('2. Repository-slug#id (e.g., org/repo#1000)', { indent: 4 });
+    logInfo('3. A full issue link URL', { indent: 4 });
+    logInfo('* A scope field consists of existing packages.', { indent: 3 });
+    logInfo('');
+    logInfo(`Found ${numberOfEntries} entries to parse.`, { indent: 1 });
+    logInfo('');
+}
+function getTitleColor(sectionName) {
+    if (sectionName === 'warning') {
+        return chalk.yellow;
+    }
+    if (sectionName === 'invalid') {
+        return chalk.red;
+    }
+    let defaultColor = chalk.blue;
+    if (isBreakingChangeSection(sectionName)) {
+        // To avoid tricks in tests, let's simplify the implementation.
+        defaultColor = (value) => {
+            return chalk.bold(chalk.blue(value));
+        };
+    }
+    return defaultColor;
+}
+function isBreakingChangeSection(sectionName) {
+    return sectionName === 'breaking' || sectionName === 'major' || sectionName === 'minor';
+}
+function displayWarningEntry(entry) {
+    logInfo(`» file://${entry.changesetPath}`, { indent: 2 });
+    for (const validationMessage of (entry.data.validations || [])) {
+        logInfo(`- ${validationMessage}`, { indent: 3 });
+    }
+}
+function displayValidEntry(entry, sectionName, isSinglePackage, transformScope) {
+    const isEntryFullyValid = !entry.data.validations?.length;
+    const scopeFormatted = transformScope ?
+        entry.data.scope.map(scope => transformScope(scope).displayName) :
+        entry.data.scope;
+    const scope = entry.data.scope.length ?
+        chalk.grey(scopeFormatted?.join(', ')) :
+        `${chalk.italic(chalk.grey('(no scope)'))}`;
+    const validationIndicator = isEntryFullyValid ? chalk.green('+') : chalk.yellow('x');
+    const shouldTrimMessage = String(entry.data.mainContent).length > 100;
+    const trimmedMessageContent = shouldTrimMessage ? entry.data.mainContent?.slice(0, 100) + '...' : entry.data.mainContent;
+    if (isSinglePackage) {
+        logInfo(`${validationIndicator} ${trimmedMessageContent}`, { indent: 2 });
+    }
+    else {
+        logInfo(`${validationIndicator} ${scope}: ${trimmedMessageContent}`, { indent: 2 });
+    }
+    if (!isBreakingChangeSection(sectionName)) {
+        return;
+    }
+    entry.data.see.forEach(({ link }) => {
+        logInfo(`- See: ${link}`, { indent: 3 });
+    });
+    entry.data.closes.forEach(({ link }) => {
+        logInfo(`- Closes: ${link}`, { indent: 3 });
+    });
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * This function limits the size of the changelog by removing older entries.
+ */
+function truncateChangelog(length, cwd) {
+    const changelog = getChangelog(cwd);
+    if (!changelog) {
+        return;
+    }
+    const entryHeader = '## [\\s\\S]+?';
+    const entryHeaderRegexp = new RegExp(`\\n(${entryHeader})(?=\\n${entryHeader}|$)`, 'g');
+    const entries = [...changelog.matchAll(entryHeaderRegexp)]
+        .filter(match => match && match[1])
+        .map(match => match[1]);
+    if (!entries.length) {
+        return;
+    }
+    const truncatedEntries = entries.slice(0, length);
+    const repositoryUrl = workspaces.getRepositoryUrl(cwd);
+    const changelogFooter = entries.length > truncatedEntries.length ?
+        `\n\n---\n\nTo see all releases, visit the [release page](${repositoryUrl}/releases).\n` :
+        '\n';
+    const truncatedChangelog = CHANGELOG_HEADER + '\n\n' + truncatedEntries.join('\n').trim() + changelogFooter;
+    saveChangelog(truncatedChangelog, cwd);
+}
+function getChangelog(cwd) {
+    const changelogFile = upath.join(cwd, CHANGELOG_FILE);
+    if (!fs.existsSync(changelogFile)) {
+        return null;
+    }
+    return fs.readFileSync(changelogFile, 'utf-8');
+}
+function saveChangelog(content, cwd) {
+    const changelogFile = upath.join(cwd, CHANGELOG_FILE);
+    fs.writeFileSync(changelogFile, content, 'utf-8');
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * This function writes the generated changelog content to the repository's changelog file.
+ *
+ * It reads the existing changelog (if any), inserts the new changelog content after the defined header,
+ * writes the updated content back to the changelog file, and truncates the changelog to keep a manageable length.
+ */
+async function modifyChangelog(newChangelog, cwd) {
+    const changelogPath = upath.join(cwd, CHANGELOG_FILE);
+    const existingChangelog = await readExistingChangelog(changelogPath);
+    const updatedChangelog = prepareChangelogContent(existingChangelog, newChangelog);
+    logInfo(`○ ${chalk.cyan('Appending changes to the existing changelog...')}`);
+    await fs$1.writeFile(changelogPath, updatedChangelog, 'utf-8');
+    await truncateChangelog(5, cwd);
+}
+/**
+ * Reads the existing changelog file or returns an empty string if the file doesn't exist.
+ */
+async function readExistingChangelog(changelogPath) {
+    try {
+        return await fs$1.readFile(changelogPath, 'utf-8');
+    }
+    catch {
+        logInfo(`○ ${chalk.yellow('CHANGELOG.md not found.')}`);
+        return '';
+    }
+}
+/**
+ * Prepares the new changelog content by inserting it after the header or at the beginning if header is missing.
+ */
+function prepareChangelogContent(existingChangelog, newChangelog) {
+    const headerIndex = existingChangelog.indexOf(CHANGELOG_HEADER);
+    if (headerIndex === -1) {
+        return `${CHANGELOG_HEADER}\n\n${newChangelog}${existingChangelog}`;
+    }
+    const insertPosition = headerIndex + CHANGELOG_HEADER.length;
+    return existingChangelog.slice(0, insertPosition) + '\n\n' + newChangelog + existingChangelog.slice(insertPosition);
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Custom error class for handling a case when a user aborts the process (at any stage).
+ */
+class UserAbortError extends Error {
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+const CLI_INDENT_SIZE = 3;
+/**
+ * Prompts the user to provide a new version for a package.
+ *
+ * Validates the input (version format, version higher than current, availability).
+ *
+ * Optionally shows warnings for invalid changes and allows user to abort.
+ */
+async function provideNewVersion(options) {
+    if (options.displayValidationWarning) {
+        // Display warning about invalid changes
+        displayInvalidChangesWarning();
+        // Ask for confirmation to continue
+        const shouldContinue = await askContinueConfirmation(options.indentLevel);
+        if (!shouldContinue) {
+            throw new UserAbortError('Aborted while detecting invalid changes.');
+        }
+    }
+    const question = createVersionQuestion(options);
+    const answers = await inquirer.prompt(question);
+    return answers.version;
+}
+/**
+ * Displays a warning message about invalid changes in a visible color.
+ */
+function displayInvalidChangesWarning() {
+    logInfo('');
+    logInfo(chalk.yellow(chalk.bold(`⚠️  ${chalk.underline('WARNING: Invalid changes detected!')}`)));
+    logInfo('');
+    logInfo(chalk.yellow('You can cancel the process, fix the invalid files, and run the tool again.'));
+    logInfo(chalk.yellow('Alternatively, you can continue - but invalid values will be lost.'));
+    logInfo('');
+}
+/**
+ * Asks the user if they want to continue with the version bump process.
+ */
+async function askContinueConfirmation(indentLevel = 0) {
+    const question = {
+        type: 'confirm',
+        name: 'continue',
+        message: 'Should continue?',
+        default: false,
+        prefix: ' '.repeat(indentLevel * CLI_INDENT_SIZE) + chalk.cyan('?')
+    };
+    const answers = await inquirer.prompt(question);
+    return answers.continue;
+}
+/**
+ * Creates a prompt question for version input with validation.
+ */
+function createVersionQuestion(options) {
+    const { version, packageName, bumpType, indentLevel = 0 } = options;
+    const suggestedVersion = semver.inc(version, bumpType) || version;
+    const message = 'Type the new version ' +
+        `(current: "${version}", suggested: "${suggestedVersion}", or "internal" for internal changes):`;
+    return [{
+            type: 'input',
+            name: 'version',
+            default: suggestedVersion,
+            message,
+            filter: (newVersion) => newVersion.trim(),
+            async validate(newVersion) {
+                // Allow 'internal' as a special version.
+                if (newVersion === 'internal') {
+                    return true;
+                }
+                // Require a semver valid version, e.g., `1.0.0`, `1.0.0-alpha.0`, etc.
+                if (!semver.valid(newVersion)) {
+                    return 'Please provide a valid version or "internal" for internal changes.';
+                }
+                // The provided version must be higher than the current version.
+                if (!semver.gt(newVersion, version)) {
+                    return `Provided version must be higher than "${version}".`;
+                }
+                const isAvailable = await npm.checkVersionAvailability(newVersion, packageName);
+                // Check against availability in the npm registry.
+                if (!isAvailable) {
+                    return 'Given version is already taken.';
+                }
+                return true;
+            },
+            prefix: ' '.repeat(indentLevel * CLI_INDENT_SIZE) + chalk.cyan('?')
+        }];
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Determines the next version for a single package or a mono-repository setup based on
+ * the change sections, * user input, and semantic versioning rules.
+ *
+ * The function handles:
+ * * Automatic version bump calculation from categorized changelog sections (major, minor, patch).
+ * * Accepting explicit next version overrides, including a special `internal` version bump.
+ * * User prompts for version input when no explicit version is provided.
+ */
+async function determineNextVersion(options) {
+    const { sections, currentVersion, packageName, nextVersion } = options;
+    if (nextVersion === 'internal') {
+        const internalVersionBump = getInternalVersionBump(currentVersion);
+        logInfo(`○ ${chalk.cyan(`Determined the next version to be ${internalVersionBump.newVersion}.`)}`);
+        return internalVersionBump;
+    }
+    if (nextVersion) {
+        logInfo(`○ ${chalk.cyan(`Determined the next version to be ${nextVersion}.`)}`);
+        return { newVersion: nextVersion, isInternal: false };
+    }
+    logInfo(`○ ${chalk.cyan('Determining the new version...')}`);
+    let bumpType = 'patch';
+    if (sections.minor.entries.length || sections.feature.entries.length) {
+        bumpType = 'minor';
+    }
+    if (sections.major.entries.length) {
+        bumpType = 'major';
+    }
+    const areErrorsPresent = !!sections.invalid.entries.length;
+    const areWarningsPresent = Object.values(sections).some(section => section.entries.some(entry => entry.data.validations && entry.data.validations.length > 0));
+    const userProvidedVersion = await provideNewVersion({
+        packageName,
+        bumpType,
+        version: currentVersion,
+        displayValidationWarning: areErrorsPresent || areWarningsPresent
+    });
+    if (userProvidedVersion === 'internal') {
+        return getInternalVersionBump(currentVersion);
+    }
+    return { newVersion: userProvidedVersion, isInternal: false };
+}
+function getInternalVersionBump(currentVersion) {
+    const version = semver.inc(currentVersion, 'patch');
+    if (!version) {
+        throw new Error('Unable to determine new version based on the version in root package.json.');
+    }
+    return { newVersion: version, isInternal: true };
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * A utility class that wraps a Promise of an array and provides async array-like operations.
+ */
+class AsyncArray {
+    promise;
+    /**
+     * Creates a new `AsyncArray` instance.
+     */
+    constructor(promise) {
+        this.promise = promise;
+    }
+    /**
+     * Creates an `AsyncArray` from a given promise.
+     */
+    static from(promise) {
+        return new AsyncArray(promise);
+    }
+    /**
+     * Asynchronously maps each item in the array using the provided callback.
+     */
+    map(fn) {
+        const newPromise = this.promise.then(arr => Promise.all(arr.map(fn)));
+        return new AsyncArray(newPromise);
+    }
+    /**
+     * Flattens one level of nesting in an array of arrays.
+     */
+    flat() {
+        const newPromise = this.promise.then(arr => arr.flat());
+        return new AsyncArray(newPromise);
+    }
+    /**
+     * Maps each item using a callback that returns an array (or promise of an array),
+     * then flattens the result by one level.
+     */
+    flatMap(fn) {
+        const newPromise = this.promise.then(async (arr) => {
+            const mapped = await Promise.all(arr.map(fn));
+            return mapped.flat();
+        });
+        return new AsyncArray(newPromise);
+    }
+    /**
+     * Allows chaining or awaiting the result of the internal promise.
+     */
+    then(onfulfilled) {
+        return this.promise.then(onfulfilled);
+    }
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Retrieves the names and versions of packages found in both the main repository and any external repositories.
+ */
+async function findPackages(options) {
+    const { cwd, packagesDirectory, externalRepositories, shouldIgnoreRootPackage = false } = options;
+    const externalPackagesPromises = externalRepositories.map(externalRepository => {
+        return workspaces.findPathsToPackages(externalRepository.cwd, externalRepository.packagesDirectory, { includePackageJson: true });
+    });
+    const promise = Promise.all([
+        workspaces.findPathsToPackages(cwd, packagesDirectory, { includeCwd: !shouldIgnoreRootPackage, includePackageJson: true }),
+        ...externalPackagesPromises
+    ]);
+    return AsyncArray.from(promise)
+        .flat()
+        .map(packagePath => fs$1.readJson(packagePath))
+        .map(({ name, version }) => [name, version])
+        .then(entries => new Map(entries.sort(([a], [b]) => a.localeCompare(b))));
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Generates a categorized summary of packages released in the new version,
+ * including new packages, major, minor, feature, and other releases.
+ *
+ * This function analyzes changelog sections and package metadata to:
+ * * Identify new packages introduced with version '0.0.1'.
+ * * Group packages by release type based on the changelog sections: major, minor, and features.
+ * * Exclude packages already accounted for in higher-priority release categories from lower ones.
+ * * Provide a fallback category for "other releases" that don't fall into the above groups.
+ */
+async function composeReleaseSummary(options) {
+    const { sections, currentVersion, newVersion, packagesMetadata } = options;
+    const versionUpgradeText = `v${currentVersion} => v${newVersion}`;
+    const packageNames = [...packagesMetadata.keys()];
+    const newVersionReleases = getNewVersionReleases(packagesMetadata);
+    const majorReleases = getScopeWithOrgNamespace(sections.major.entries, { packagesToRemove: newVersionReleases, packageNames });
+    const minorReleases = getScopeWithOrgNamespace(sections.minor.entries, {
+        packagesToRemove: [...majorReleases, ...newVersionReleases],
+        packageNames
+    });
+    const newFeaturesReleases = getScopeWithOrgNamespace(sections.feature.entries, {
+        packagesToRemove: [...minorReleases, ...majorReleases, ...newVersionReleases],
+        packageNames
+    });
+    const packagesToRemoveFromOtherReleases = [majorReleases, minorReleases, newFeaturesReleases, newVersionReleases].flat();
+    const otherReleases = packageNames
+        .filter(packageName => !packagesToRemoveFromOtherReleases.includes(packageName))
+        .sort();
+    return [
+        { title: 'New packages:', version: `v${newVersion}`, packages: newVersionReleases },
+        { title: 'Major releases (contain major breaking changes):', version: versionUpgradeText, packages: majorReleases },
+        { title: 'Minor releases (contain minor breaking changes):', version: versionUpgradeText, packages: minorReleases },
+        { title: 'Releases containing new features:', version: versionUpgradeText, packages: newFeaturesReleases },
+        { title: 'Other releases:', version: versionUpgradeText, packages: otherReleases }
+    ].filter(release => release.packages?.length > 0);
+}
+function getNewVersionReleases(packages) {
+    return [...packages]
+        .filter(([, version]) => version === '0.0.1')
+        .map(([packageName]) => packageName)
+        .sort();
+}
+function getScopeWithOrgNamespace(entries = [], { packagesToRemove, packageNames }) {
+    const uniqueScopes = entries
+        .flatMap(entry => entry.data.scope)
+        .filter(Boolean)
+        .filter((item, index, array) => array.indexOf(item) === index);
+    const packagesFullNames = uniqueScopes.map(scope => {
+        return packageNames.find(packageName => getPackageName(packageName) === scope);
+    });
+    return packagesFullNames.filter(packageName => !packagesToRemove.includes(packageName));
+}
+function getPackageName(value) {
+    if (value.includes('/')) {
+        return value.split('/').at(1);
+    }
+    return value;
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Gathers changelog entry file paths (Markdown files) from the main repository and any configured external repositories.
+ */
+async function findChangelogEntryPaths(options) {
+    const { cwd, externalRepositories, shouldSkipLinks } = options;
+    return AsyncArray
+        .from(Promise.resolve(externalRepositories))
+        .map(async (repo) => {
+        const changesetGlob = await glob('**/*.md', {
+            cwd: upath.join(repo.cwd, CHANGESET_DIRECTORY),
+            absolute: true
+        });
+        return {
+            filePaths: changesetGlob.map(p => upath.normalize(p)),
+            gitHubUrl: await workspaces.getRepositoryUrl(repo.cwd, { async: true }),
+            shouldSkipLinks: !!repo.shouldSkipLinks,
+            cwd: repo.cwd,
+            isRoot: false
+        };
+    })
+        .then(async (externalResults) => {
+        const mainChangesetGlob = await glob('**/*.md', {
+            cwd: upath.join(cwd, CHANGESET_DIRECTORY),
+            absolute: true
+        });
+        const mainEntry = {
+            filePaths: mainChangesetGlob.map(p => upath.normalize(p)),
+            gitHubUrl: await workspaces.getRepositoryUrl(cwd, { async: true }),
+            shouldSkipLinks,
+            cwd,
+            isRoot: true
+        };
+        return [mainEntry, ...externalResults];
+    });
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Sorts parsed files according to the rules:
+ * 1. Entries with more scopes at the top.
+ * 2. Entries with single scope grouped by scope and sorted by date within a group.
+ * 3. Entries with no scope at the bottom.
+ */
+function sortEntriesByScopeAndDate(entries) {
+    return entries.sort((itemBefore, itemAfter) => {
+        const beforeScopeCount = itemBefore.data.scope.length;
+        const afterScopeCount = itemAfter.data.scope.length;
+        // Both have single scope - group by scope name first.
+        if (beforeScopeCount === 1 && afterScopeCount === 1) {
+            const firstScope = itemBefore.data.scope.at(0);
+            const secondScope = itemAfter.data.scope.at(0);
+            if (firstScope !== secondScope) {
+                return firstScope.localeCompare(secondScope); // Alphabetical scope order.
+            }
+            // Same scope - sort by date (older first).
+            return itemBefore.createdAt.getTime() - itemAfter.createdAt.getTime();
+        }
+        // Both have the same number of scopes - sort by date (older first).
+        if (beforeScopeCount === afterScopeCount) {
+            return itemBefore.createdAt.getTime() - itemAfter.createdAt.getTime();
+        }
+        // Sort by number of scopes.
+        return afterScopeCount - beforeScopeCount;
+    });
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+function normalizeEntry(entry, isSinglePackage) {
+    // Normalize type.
+    const typeNormalized = getTypeNormalized(entry.data.type, isSinglePackage);
+    // Normalize scope.
+    const scopeNormalized = toArray(entry.data.scope)
+        .filter(scope => scope)
+        .map(scopeEntry => String(scopeEntry).toLowerCase())
+        .sort();
+    // Normalize closes.
+    const closesNormalized = toArray(entry.data.closes)
+        .filter(closes => closes)
+        .map(closes => String(closes));
+    // Normalize see.
+    const seeNormalized = toArray(entry.data.see)
+        .filter(see => see).map(see => String(see));
+    // Normalize community credits.
+    const communityCreditsNormalized = toArray(entry.data.communityCredits)
+        .filter(see => see)
+        .map(credits => ensureAt(String(credits)));
+    return {
+        ...entry,
+        data: {
+            type: typeNormalized,
+            scope: deduplicate(scopeNormalized),
+            closes: deduplicate(closesNormalized),
+            see: deduplicate(seeNormalized),
+            communityCredits: deduplicate(communityCreditsNormalized),
+            validations: []
+        }
+    };
+}
+function getTypeNormalized(type, isSinglePackage) {
+    const typeCapitalized = capitalize(type);
+    const expectedBreakingChangeTypes = ['Major breaking change', 'Minor breaking change'];
+    if (isSinglePackage && expectedBreakingChangeTypes.includes(typeCapitalized)) {
+        return 'Breaking change';
+    }
+    return typeCapitalized;
+}
+function capitalize(value) {
+    const valueStr = String(value);
+    return valueStr.charAt(0).toUpperCase() + valueStr.slice(1).toLowerCase();
+}
+function ensureAt(str) {
+    return str.startsWith('@') ? str : '@' + str;
+}
+function deduplicate(packageNames) {
+    return [...new Set(packageNames)];
+}
+function toArray(input) {
+    if (!input) {
+        return [];
+    }
+    if (typeof input === 'string') {
+        return [input];
+    }
+    return input;
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Reads and processes input files to extract changelog entries.
+ */
+function parseChangelogEntries(entryPaths, isSinglePackage) {
+    const fileEntries = entryPaths.reduce((acc, { filePaths, gitHubUrl, shouldSkipLinks }) => {
+        for (const changesetPath of filePaths) {
+            acc.push({ changesetPath, gitHubUrl, shouldSkipLinks });
+        }
+        return acc;
+    }, []);
+    return AsyncArray
+        .from(Promise.resolve(fileEntries))
+        .map(async ({ changesetPath, gitHubUrl, shouldSkipLinks }) => ({
+        ...matter(await fs$1.readFile(changesetPath, 'utf-8')),
+        gitHubUrl,
+        changesetPath,
+        shouldSkipLinks,
+        createdAt: extractDateFromFilename(changesetPath)
+    }))
+        .map(entry => normalizeEntry(entry, isSinglePackage))
+        .then(entries => sortEntriesByScopeAndDate(entries));
+}
+/**
+ * Extracts date from an entry filename (`YYYYMMDDHHMMSS_*.md`).
+ *
+ * Defaults to the current date if the filename does not match the expected format.
+ */
+function extractDateFromFilename(changesetPath) {
+    const now = new Date();
+    const filename = changesetPath.split('/').pop() || '';
+    const dateMatch = filename.match(/^(\d{14})_/);
+    if (!dateMatch || !dateMatch[1]) {
+        // Fallback to the current date if no date pattern found.
+        return now;
+    }
+    const parsedDate = parse(dateMatch[1], 'yyyyMMddHHmmss', now);
+    // Validate the parsed date and fallback to the current date when failed.
+    if (!isValid(parsedDate)) {
+        return now;
+    }
+    return parsedDate;
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Custom error class for handling validation errors in the changelog generation process.
+ */
+class InternalError extends Error {
+    constructor() {
+        const message = 'No valid entries were found. Please ensure that:\n' +
+            '1) Input files exist in the `.changelog/` directory.\n' +
+            '2) The `cwd` parameter points to the root of your project.\n' +
+            '3) The `packagesDirectory` parameter correctly specifies the packages folder.\n' +
+            'If no errors appear in the console but inputs are present, your project configuration may be incorrect.\n' +
+            'If validation errors are shown, please resolve them according to the details provided.\n';
+        super(message);
+    }
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Filters and returns only those changelog sections that:
+ * * Have at least one entry.
+ * * Are not explicitly marked to be excluded from the final changelog.
+ *
+ * This is used to determine which sections should be displayed or processed for changelog generation.
+ */
+function filterVisibleSections(sectionsWithEntries) {
+    const sectionsToDisplay = Object.entries(sectionsWithEntries)
+        .filter(([, { entries, excludeInChangelog }]) => {
+        return entries?.length && !excludeInChangelog;
+    })
+        .map(([, section]) => section);
+    if (!sectionsToDisplay.length) {
+        throw new InternalError();
+    }
+    return sectionsToDisplay;
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Formats a date string `YYYY-MM-DD` into a human-readable format for the changelog.
+ */
+function getDateFormatted(date) {
+    return format(parse(date, 'yyyy-MM-dd', new Date()), 'LLLL d, yyyy');
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Generates a formatted changelog string for a new version release.
+ *
+ * This function constructs the changelog content including
+ * * A version header with a link to the GitHub comparison view (except for an initial version).
+ * * Sections with grouped changelog entries and their messages.
+ * * A collapsible summary of released packages and their version bumps for a mono-repository setup.
+ * * Special handling for internal-only releases and single-package repositories.
+ */
+async function composeChangelog(options) {
+    const { cwd, date, currentVersion, newVersion, sections, releasedPackagesInfo, isInternal, isSinglePackage, packagesMetadata } = options;
+    const gitHubUrl = await workspaces.getRepositoryUrl(cwd, { async: true });
+    const dateFormatted = getDateFormatted(date);
+    const packagesNames = [...packagesMetadata.keys()];
+    const header = currentVersion === '0.0.1' ?
+        `## ${newVersion} (${dateFormatted})` :
+        `## [${newVersion}](${gitHubUrl}/compare/v${currentVersion}...v${newVersion}) (${dateFormatted})`;
+    const sectionsAsString = sections.map(({ title, entries }) => ([
+        `### ${title}`,
+        '',
+        ...entries.map(entry => entry.message),
+        ''
+    ])).flat().join('\n');
+    const packagesVersionBumps = releasedPackagesInfo.map(({ title, version, packages }) => ([
+        '',
+        title,
+        '',
+        ...packages.map(packageName => `* [${packageName}](${NPM_URL}/${packageName}/v/${newVersion}): ${version}`)
+    ])).flat().join('\n');
+    const internalVersionsBumps = [
+        '',
+        SECTIONS.other.title + ':',
+        '',
+        packagesNames.map(name => `* [${name}](${NPM_URL}/${name}/v/${newVersion}): v${currentVersion} => v${newVersion}`)
+    ].flat().join('\n');
+    const changelog = [
+        header,
+        '',
+        isInternal ? 'Internal changes only (updated dependencies, documentation, etc.).\n' : sectionsAsString
+    ];
+    if (!isSinglePackage) {
+        changelog.push('### Released packages', '', `Check out the [Versioning policy](${VERSIONING_POLICY_URL}) guide for more information.`, '', '<details>', '<summary>Released packages (summary)</summary>', isInternal ? internalVersionsBumps : packagesVersionBumps, '</details>', '');
+    }
+    return changelog.join('\n');
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Cleans up the input files that have been incorporated into the changelog by deleting them
+ * and removing any resulting empty directories both in the current repository and in any external repositories.
+ */
+async function removeChangelogEntryFiles(entryPaths) {
+    logInfo(`○ ${chalk.cyan('Removing the changeset files...')}`);
+    await Promise.all(entryPaths
+        .flatMap(repo => repo.filePaths)
+        .map(file => fs$1.unlink(file)));
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+async function commitChanges(version, repositories) {
+    const message = `Changelog for v${version}. [skip ci]`;
+    logInfo(`○ ${chalk.cyan('Committing changes...')}`);
+    for (const { cwd, isRoot, filePaths } of repositories) {
+        // Copy to avoid modifying the original array.
+        const files = filePaths.slice(0);
+        if (isRoot) {
+            files.unshift(upath.join(cwd, CHANGELOG_FILE));
+        }
+        logInfo(`◌ Processing "${cwd}".`, { indent: 1 });
+        await tools.commit({ cwd, message, files })
+            .catch(error => {
+            logInfo('An error occurred while committing changes.', { indent: 2 });
+            logInfo(chalk.red(error.message), { indent: 2 });
+        });
+    }
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+/**
+ * Orchestrates the full changelog generation workflow.
+ *
+ * This function:
+ * * Reads the current package version and metadata.
+ * * Locates all changelog entry files from the main and external repositories.
+ * * Parses, validates, and groups entries by their section.
+ * * Optionally displays the changes for manual inspection.
+ * * Prompts for the next version if not provided via `options.nextVersion`.
+ * * Computes the released package information based on version changes.
+ * * Assembles a new changelog based on the visible entries.
+ * * Optionally writes the new changelog to disk and removes the processed entry files.
+ * * Commits the changes (changelog and removed files) to the Git repository.
+ *
+ * If `disableFilesystemOperations` is enabled, file operations (writing/committing) will be skipped,
+ * and the assembled changelog object will be returned instead.
+ */
+const main = async (options) => {
+    const { nextVersion, packagesDirectory, isSinglePackage, transformScope, npmPackageToCheck, cwd = process.cwd(), externalRepositories = [], date = format(new Date(), 'yyyy-MM-dd'), shouldSkipLinks = false, shouldIgnoreRootPackage = false, disableFilesystemOperations = false } = options;
+    const { version: currentVersion, name: rootPackageName } = await workspaces.getPackageJson(cwd, { async: true });
+    const packagesMetadata = await findPackages({
+        cwd,
+        packagesDirectory,
+        shouldIgnoreRootPackage,
+        externalRepositories
+    });
+    const entryPaths = await findChangelogEntryPaths({
+        cwd,
+        externalRepositories,
+        shouldSkipLinks
+    });
+    const parsedChangesetFiles = await parseChangelogEntries(entryPaths, isSinglePackage);
+    const sectionsWithEntries = groupEntriesBySection({
+        packagesMetadata,
+        transformScope,
+        isSinglePackage,
+        files: parsedChangesetFiles
+    });
+    // Log changes in the console only when `nextVersion` is not provided.
+    if (!nextVersion) {
+        displayChanges({
+            isSinglePackage,
+            transformScope,
+            sections: sectionsWithEntries
+        });
+    }
+    // Display a prompt to provide a new version in the console.
+    const { isInternal, newVersion } = await determineNextVersion({
+        currentVersion,
+        nextVersion,
+        sections: sectionsWithEntries,
+        packageName: shouldIgnoreRootPackage ? npmPackageToCheck : rootPackageName
+    });
+    const releasedPackagesInfo = await composeReleaseSummary({
+        currentVersion,
+        newVersion,
+        packagesMetadata,
+        sections: sectionsWithEntries
+    });
+    const newChangelog = await composeChangelog({
+        currentVersion,
+        cwd,
+        date,
+        newVersion,
+        isInternal,
+        isSinglePackage,
+        packagesMetadata,
+        releasedPackagesInfo,
+        sections: filterVisibleSections(sectionsWithEntries)
+    });
+    if (disableFilesystemOperations) {
+        return newChangelog;
+    }
+    await removeChangelogEntryFiles(entryPaths);
+    await modifyChangelog(newChangelog, cwd);
+    await commitChanges(newVersion, entryPaths.map(({ cwd, isRoot, filePaths }) => ({ cwd, isRoot, filePaths })));
+    logInfo('○ ' + chalk.green('Done!'));
+};
+/**
+ * Entry point for generating a changelog with error handling.
+ *
+ * This wrapper ensures that:
+ * * Interruptions from the user (e.g., Ctrl+C or intentional aborts) exit silently with code 0.
+ * * Expected and unexpected internal errors are logged to the console and exit with code 1.
+ * * Other unexpected errors are re-thrown for higher-level handling.
+ */
+const generateChangelog = async (options) => {
+    return main(options)
+        .catch(error => {
+        if (isExpectedError(error)) {
+            process.exit(0);
+        }
+        else if (!(error instanceof InternalError)) {
+            throw error;
+        }
+        else {
+            console.error(chalk.red('Error: ' + error.message));
+            process.exit(1);
+        }
+    });
+};
+function isError(error) {
+    return typeof error === 'object' && error !== null && 'message' in error;
+}
+function isExpectedError(error) {
+    if (isError(error) && error.message.includes('User force closed the prompt with SIGINT')) {
+        return true;
+    }
+    if (error instanceof UserAbortError) {
+        return true;
+    }
+    return false;
+}
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+const generateChangelogForMonoRepository = async (options) => {
+    const { date, cwd, externalRepositories, nextVersion, disableFilesystemOperations, npmPackageToCheck, packagesDirectory, shouldSkipLinks, shouldIgnoreRootPackage, transformScope } = options;
+    return generateChangelog({
+        nextVersion,
+        cwd,
+        packagesDirectory,
+        externalRepositories,
+        transformScope,
+        date,
+        shouldSkipLinks,
+        disableFilesystemOperations,
+        ...(shouldIgnoreRootPackage && npmPackageToCheck ?
+            { shouldIgnoreRootPackage: true, npmPackageToCheck } :
+            { shouldIgnoreRootPackage: false }),
+        isSinglePackage: false
+    });
+};
+
+/**
+ * @license Copyright (c) 2003-2025, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md.
+ */
+const generateChangelogForSingleRepository = async (options) => {
+    const { cwd, date, externalRepositories, nextVersion, disableFilesystemOperations, shouldSkipLinks } = options;
+    return generateChangelog({
+        nextVersion,
+        cwd,
+        externalRepositories,
+        date,
+        shouldSkipLinks,
+        disableFilesystemOperations,
+        isSinglePackage: true,
+        packagesDirectory: null
+    });
+};
+
+export { generateChangelogForMonoRepository, generateChangelogForSingleRepository };