spectrum-cli 2.1.2 → 3.0.1

package/src/preflight.js

@@ -1,9 +1,17 @@
 #!/usr/bin/env node
 const fs = require('fs');
 const path = require('path');
-const { execSilent, execCommand, getCurrentBranch, getMainBranch, getDevelopBranch, getVersion } = require('./utils');
+const { execSilent, execCommand, getCurrentBranch, getMainBranch, getDevelopBranch } = require('./utils');
+const {
+    CHANGELOG_FILE,
+    CHANGELOG_DIR,
+    FRAGMENT_TYPES,
+    getFragmentType
+} = require('./changelog-config');
 
 const SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+const STABLE_SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+const YOUTRACK_TASK_PATTERN = /^[A-Z]+-[0-9]+$/;
 
 function ok(data) {
     return { ok: true, data };
@@ -119,7 +127,7 @@ function requireCurrentBranchUpToDateWithRemote() {
         return fail('Не удалось определить текущую ветку.');
     }
 
-    if (!execCommand('git fetch --all --prune --jobs=10')) {
+    if (!execCommand('git fetch origin --prune --tags')) {
         return fail('Не удалось получить изменения с удаленного репозитория.');
     }
 
@@ -153,17 +161,157 @@ function requireFileExists(filePath) {
     return ok();
 }
 
-function requirePackageVersion() {
-    const version = getVersion();
+const CHANGELOG_HEADING_PATTERN = /^##\s+(?:\S+\s+)?\[(\d+\.\d+\.\d+)\]/gm;
+
+function getChangelogReleaseVersions(changelogPath = CHANGELOG_FILE) {
+    let changelog;
+    try {
+        changelog = fs.readFileSync(changelogPath, 'utf8');
+    } catch (error) {
+        return [];
+    }
+
+    return [...changelog.matchAll(CHANGELOG_HEADING_PATTERN)].map((match) => match[1]);
+}
+
+function getChangelogReleaseVersion(changelogPath = CHANGELOG_FILE) {
+    return getChangelogReleaseVersions(changelogPath)[0] || null;
+}
+
+function requireChangelogReleaseVersion() {
+    const version = getChangelogReleaseVersion();
     if (!version) {
-        return fail('Не удалось прочитать версию из package.json.');
+        return fail(`Не удалось прочитать версию релиза из ${CHANGELOG_FILE}. Ожидается заголовок "## 🚀 [X.Y.Z]".`);
     }
-    if (!SEMVER_PATTERN.test(version)) {
-        return fail(`Версия "${version}" не соответствует semver.`);
+    if (!STABLE_SEMVER_PATTERN.test(version)) {
+        return fail(`Версия "${version}" из ${CHANGELOG_FILE} должна быть стабильным SemVer X.Y.Z.`);
     }
     return ok({ version });
 }
 
+function requireChartChangelogVersion(chartDir, version) {
+    const changelogPath = toPosixPath(path.join(String(chartDir || ''), 'CHANGELOG.md'));
+    if (!fs.existsSync(changelogPath)) {
+        return fail(`Файл "${changelogPath}" не существует. Заполните changelog чарта перед созданием тега.`);
+    }
+
+    let changelog;
+    try {
+        changelog = fs.readFileSync(changelogPath, 'utf8');
+    } catch (error) {
+        return fail(`Не удалось прочитать "${changelogPath}".`);
+    }
+
+    const escapedVersion = String(version || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const headingPattern = new RegExp(`^##\\s+(?:\\S+\\s+)?\\[${escapedVersion}\\]`, 'm');
+    if (!headingPattern.test(changelog)) {
+        return fail(`В "${changelogPath}" нет заголовка "## [${version}]". Добавьте запись о версии перед созданием тега.`);
+    }
+
+    return ok({ chartChangelogPath: changelogPath });
+}
+
+function compareStableVersions(left, right) {
+    const leftParts = String(left).split('.').map(Number);
+    const rightParts = String(right).split('.').map(Number);
+    for (let index = 0; index < 3; index += 1) {
+        if (leftParts[index] !== rightParts[index]) {
+            return leftParts[index] - rightParts[index];
+        }
+    }
+    return 0;
+}
+
+function requireNoPendingRelease(stableVersion) {
+    if (!STABLE_SEMVER_PATTERN.test(String(stableVersion || ''))) {
+        return fail('Для проверки незакрытых релизов требуется последний стабильный SemVer X.Y.Z.');
+    }
+
+    const changelogReleaseVersions = getChangelogReleaseVersions();
+    const pendingVersions = [...new Set(changelogReleaseVersions)]
+        .filter((version) => compareStableVersions(version, stableVersion) > 0)
+        .sort((left, right) => compareStableVersions(right, left));
+
+    if (pendingVersions.length > 0) {
+        return fail(
+            `В ${CHANGELOG_FILE} найдены незакрытые релизы новее стабильного тега v${stableVersion}: ${pendingVersions.join(', ')}. ` +
+            'Сначала выполните "spectrum release deploy", дождитесь успешного stable pipeline и выполните "spectrum release close".'
+        );
+    }
+
+    return ok({ changelogReleaseVersions });
+}
+
+function requireLatestStableVersion() {
+    const mainBranch = getMainBranch();
+    const tagNames = execSilent(`git tag --merged origin/${mainBranch} --list "v*"`);
+    const remoteTagRefs = execSilent('git ls-remote --refs --tags origin "refs/tags/v*"');
+    if (tagNames === null || remoteTagRefs === null) {
+        return fail(`Не удалось проверить стабильные теги, достижимые из origin/${mainBranch}.`);
+    }
+
+    const remoteTagNames = new Set();
+    for (const line of remoteTagRefs.split('\n')) {
+        const match = line.trim().match(/^[0-9a-f]+\s+refs\/tags\/(v\d+\.\d+\.\d+)$/i);
+        if (match) remoteTagNames.add(match[1]);
+    }
+
+    const versions = new Set();
+    for (const line of tagNames.split('\n')) {
+        const tagName = line.trim();
+        const match = tagName.match(/^v(\d+\.\d+\.\d+)$/);
+        if (match && remoteTagNames.has(tagName) && STABLE_SEMVER_PATTERN.test(match[1])) {
+            versions.add(match[1]);
+        }
+    }
+
+    if (versions.size === 0) {
+        return fail(`В origin/${mainBranch} не найден достижимый стабильный тег vX.Y.Z.`);
+    }
+
+    const stableVersion = [...versions].sort(compareStableVersions).at(-1);
+    return ok({ stableVersion });
+}
+
+function requireStableTagAtHead(version) {
+    if (!STABLE_SEMVER_PATTERN.test(String(version || ''))) {
+        return fail('Для закрытия релиза требуется стабильная версия X.Y.Z.');
+    }
+
+    const head = execSilent('git rev-parse HEAD');
+    const tagRefs = execSilent(`git ls-remote --tags origin "refs/tags/v${version}" "refs/tags/v${version}^{}"`);
+    if (!head || tagRefs === null) {
+        return fail(`Не удалось проверить стабильный тег "v${version}".`);
+    }
+
+    let tagCommit = null;
+    for (const line of tagRefs.split('\n')) {
+        const [sha, ref] = line.trim().split(/\s+/);
+        if (ref === `refs/tags/v${version}^{}`) {
+            tagCommit = sha;
+            break;
+        }
+        if (ref === `refs/tags/v${version}`) {
+            tagCommit = sha;
+        }
+    }
+
+    if (!tagCommit) {
+        return fail(`Стабильный тег "v${version}" отсутствует в origin.`);
+    }
+    if (tagCommit !== head) {
+        return fail(`Стабильный тег "v${version}" указывает не на текущий commit main/master.`);
+    }
+    return ok({ stableVersion: version });
+}
+
+function requireYouTrackTask(task) {
+    if (!YOUTRACK_TASK_PATTERN.test(String(task || ''))) {
+        return fail('Номер задачи должен соответствовать формату YOUTRACK-ID, например AR-123.');
+    }
+    return ok({ task });
+}
+
 function requireTagMissing(tagName) {
     const localTag = execSilent(`git tag -l "${tagName}"`);
     if (localTag && localTag.trim()) {
@@ -178,25 +326,35 @@ function requireTagMissing(tagName) {
     return ok();
 }
 
-function requireOnReleaseBranch() {
-    const currentBranch = getCurrentBranch();
-    if (!currentBranch) {
-        return fail('Не удалось определить текущую ветку.');
+function requireReleaseVersionAvailable(version) {
+    if (!STABLE_SEMVER_PATTERN.test(String(version || ''))) {
+        return fail('Целевая release-версия должна соответствовать X.Y.Z.');
     }
-    if (!currentBranch.startsWith('release/')) {
-        return fail(`Текущая ветка "${currentBranch}", ожидалась "release/*".`);
+
+    const localBranches = execSilent(`git branch --list "hotfix/*-${version}"`);
+    if (localBranches && localBranches.trim()) {
+        return fail(`Версия "${version}" уже используется локальной hotfix-веткой.`);
+    }
+
+    const remoteBranches = execSilent(`git ls-remote --heads origin "refs/heads/hotfix/*-${version}"`);
+    if (remoteBranches === null) {
+        return fail('Не удалось проверить hotfix-ветки в origin.');
+    }
+    if (remoteBranches && remoteBranches.trim()) {
+        return fail(`Версия "${version}" уже используется hotfix-веткой в origin.`);
+    }
+
+    const localTag = execSilent(`git tag --list "v${version}"`);
+    if (localTag && localTag.trim()) {
+        return fail(`Релизный тег "v${version}" уже существует локально.`);
     }
-    return ok({ currentBranch });
-}
 
-function requireReleaseBranchMissing(branchName) {
-    const localBranch = execSilent(`git branch --list "${branchName}"`);
-    if (localBranch && localBranch.trim()) {
-        return fail(`Ветка "${branchName}" уже существует локально.`);
+    const remoteTag = execSilent(`git ls-remote --tags origin "refs/tags/v${version}" "refs/tags/v${version}^{}"`);
+    if (remoteTag === null) {
+        return fail(`Не удалось проверить тег "v${version}" в origin.`);
     }
-    const remoteBranch = execSilent(`git ls-remote --heads origin "refs/heads/${branchName}"`);
-    if (remoteBranch && remoteBranch.trim()) {
-        return fail(`Ветка "${branchName}" уже существует на origin.`);
+    if (remoteTag && remoteTag.trim()) {
+        return fail(`Релизный тег "v${version}" уже существует в origin.`);
     }
     return ok();
 }
@@ -220,6 +378,68 @@ function requireChangelogFormatted() {
     return ok({ prettierRunner: runner });
 }
 
+function findChangelogFragmentFiles(baseDir = CHANGELOG_DIR) {
+    if (!fs.existsSync(baseDir)) {
+        return [];
+    }
+
+    try {
+        return fs.readdirSync(baseDir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && !entry.name.startsWith('.'))
+            .map((entry) => toPosixPath(path.join(baseDir, entry.name)))
+            .sort();
+    } catch (error) {
+        return [];
+    }
+}
+
+function requireChangelogFragments() {
+    if (!fs.existsSync(CHANGELOG_DIR)) {
+        return fail(`Директория changelog fragments "${CHANGELOG_DIR}" не существует.`);
+    }
+
+    const fragmentFiles = findChangelogFragmentFiles();
+    if (fragmentFiles.length === 0) {
+        return fail(`В директории "${CHANGELOG_DIR}" нет changelog fragments.`);
+    }
+
+    const changelogFragments = [];
+    for (const filePath of fragmentFiles) {
+        const type = getFragmentType(filePath);
+        if (!type) {
+            return fail(`Неверное имя changelog fragment "${filePath}". Ожидается "<name>.<type>.md".`);
+        }
+
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf8');
+        } catch (error) {
+            return fail(`Не удалось прочитать changelog fragment "${filePath}".`);
+        }
+
+        const entries = content
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+        if (entries.length === 0) {
+            return fail(`Changelog fragment "${filePath}" пуст.`);
+        }
+        if (entries.some((line) => !line.startsWith('- '))) {
+            return fail(`Каждая непустая строка "${filePath}" должна начинаться с "- ".`);
+        }
+
+        changelogFragments.push({
+            filePath,
+            type,
+            section: FRAGMENT_TYPES[type].section,
+            bump: FRAGMENT_TYPES[type].bump,
+            entries
+        });
+    }
+
+    return ok({ changelogFragments });
+}
+
 function requireSingleChart() {
     const chartsDir = 'charts';
     if (!fs.existsSync(chartsDir)) {
@@ -540,6 +760,8 @@ function requireBuildCommandSupport(sourcePath) {
 
 module.exports = {
     SEMVER_PATTERN,
+    STABLE_SEMVER_PATTERN,
+    YOUTRACK_TASK_PATTERN,
     getPrettierRunner,
     requireGitRepo,
     requireCleanWorkingTree,
@@ -551,12 +773,20 @@ module.exports = {
     requireRemoteReachable,
     requireCurrentBranchUpToDateWithRemote,
     requireFileExists,
-    requirePackageVersion,
+    getChangelogReleaseVersions,
+    getChangelogReleaseVersion,
+    requireChangelogReleaseVersion,
+    requireChartChangelogVersion,
+    requireNoPendingRelease,
+    requireLatestStableVersion,
+    requireStableTagAtHead,
+    requireYouTrackTask,
     requireTagMissing,
-    requireOnReleaseBranch,
-    requireReleaseBranchMissing,
+    requireReleaseVersionAvailable,
     requirePrettierAvailable,
     requireChangelogFormatted,
+    findChangelogFragmentFiles,
+    requireChangelogFragments,
     requireSingleChart,
     findValuesYamlFiles,
     findHelmReleaseFiles,

package/src/release.js

@@ -1,11 +1,9 @@
 #!/usr/bin/env node
-const fs = require('fs');
 const { goToDevBranch, goToMainBranch, updateCurrentBranch } = require('./git');
-const { changelogChangeHeader, changelogRemoveEmptyChapters, changelogAddUnreleasedBlock } = require('./changelog');
-const path = require('path');
-const { getVersion, logSuccess, logError, execCommand, getCurrentBranch, getMainBranch, getMergeRequestUrl, getPackageManager } = require('./utils');
+const { changelogBuildRelease, changelogRemoveFragments } = require('./changelog');
+const { logSuccess, logError, execCommand, getCurrentBranch, getMainBranch } = require('./utils');
 const { runCommand } = require('./command-executor');
-const { upVersion, updateVersionFile } = require('./version');
+const { upVersion } = require('./version');
 const {
     requireGitRepo,
     requireCleanWorkingTree,
@@ -13,44 +11,32 @@ const {
     requireMainAndDevBranches,
     requireOnDevBranch,
     requireOnMainBranch,
-    requireReleaseBranchMissing,
-    requirePackageVersion,
+    requireReleaseVersionAvailable,
+    requireChangelogReleaseVersion,
+    requireNoPendingRelease,
+    requireLatestStableVersion,
+    requireStableTagAtHead,
     requireFileExists,
-    requireChangelogFormatted
+    requireChangelogFormatted,
+    requireChangelogFragments,
+    getPrettierRunner
 } = require('./preflight');
+const { CHANGELOG_FILE, CHANGELOG_DIR } = require('./changelog-config');
 
-function releaseCreate() {
-    if (!goToDevBranch()) return false;
-    if (!updateCurrentBranch()) return false;
-
-    const currentVersion = getVersion();
-    if (!currentVersion) {
-        logError('❌', 'Не удалось получить версию из package.json');
+function releaseFormatChangelog() {
+    const runner = getPrettierRunner();
+    if (!runner) {
+        logError('❌', 'Prettier недоступен.');
         return false;
     }
-
-    if (!execCommand(`git switch -c release/${currentVersion}`)) {
+    if (!execCommand(`${runner} --write ${CHANGELOG_FILE}`)) {
+        logError('❌', 'Не удалось отформатировать %s с помощью Prettier.', CHANGELOG_FILE);
         return false;
     }
-
-    logSuccess('🌱', 'Создана новая release-ветка %s.', getCurrentBranch());
+    logSuccess('🎨', 'Файл %s отформатирован.', CHANGELOG_FILE);
     return true;
 }
 
-function releasePush() {
-    const currentBranch = getCurrentBranch();
-    if (!execCommand(`git push origin ${currentBranch}`)) {
-        return false;
-    }
-
-    logSuccess('📤', 'Release-ветка %s отправлена.', currentBranch);
-    const mrUrl = getMergeRequestUrl(currentBranch, getMainBranch());
-    if (mrUrl) {
-        logSuccess('🌐', 'Создать Merge Request: %s', mrUrl);
-    }
-    return goToMainBranch();
-}
-
 function releaseCheckChangelogLint() {
     const result = requireChangelogFormatted();
     if (!result.ok) {
@@ -60,66 +46,71 @@ function releaseCheckChangelogLint() {
     return true;
 }
 
-function detectBumpType() {
-    const changelog = fs.readFileSync('CHANGELOG.md', 'utf8');
-    const lines = changelog.split('\n');
-
-    let inUnreleased = false;
-    let currentSection = null;
-    const sectionsWithEntries = new Set();
-
-    for (const line of lines) {
-        if (line.startsWith('## [Unreleased]')) {
-            inUnreleased = true;
-            continue;
-        }
-        if (inUnreleased && line.startsWith('## ')) {
-            break;
-        }
-        if (inUnreleased && line.startsWith('### ')) {
-            currentSection = line.trim();
-            continue;
-        }
-        if (inUnreleased && currentSection && line.startsWith('- ')) {
-            sectionsWithEntries.add(currentSection);
-        }
-    }
-
-    if (sectionsWithEntries.has('### 💥 Breaking change')) {
+function detectBumpType(fragments) {
+    const bumpTypes = new Set((fragments || []).map((fragment) => fragment.bump));
+    if (bumpTypes.has('major')) {
         return 'major';
     }
-    if (sectionsWithEntries.has('### 🆕 Added')) {
+    if (bumpTypes.has('minor')) {
         return 'minor';
     }
     return 'patch';
 }
 
-function runInstall() {
-    const pm = getPackageManager() || 'npm';
-    if (!execCommand(`${pm} install`)) {
-        logError('❌', 'Не удалось выполнить %s install.', pm);
-        return false;
-    }
-    logSuccess('📦', 'Lock-файл обновлен (%s install).', pm);
+function resolveReleaseVersion(stableVersion, fragments) {
+    const bumpType = detectBumpType(fragments);
+    const newVersion = upVersion(stableVersion, bumpType);
+    if (!newVersion) return null;
+    return { bumpType, newVersion };
+}
+
+function releaseCommit(context) {
+    if (!execCommand(`git add --all -- ${CHANGELOG_FILE} ${CHANGELOG_DIR}`)) return false;
+    if (!execCommand(`git commit --message "📝 Подготовить релиз ${context.newVersion}." --no-verify`)) return false;
+
+    logSuccess('📝', 'Коммит со схлопнутыми changelog fragments создан.');
     return true;
 }
 
-function releaseCommit() {
-    const lockFiles = { npm: 'package-lock.json', yarn: 'yarn.lock', bun: 'bun.lockb' };
-    const pm = getPackageManager();
-    const filesToAdd = ['CHANGELOG.md', 'package.json'];
-    if (pm && lockFiles[pm]) {
-        filesToAdd.push(lockFiles[pm]);
+function getReleasePushCommand(context) {
+    const devBranch = context && context.devBranch;
+    const targetBranch = (context && context.mainBranch) || getMainBranch();
+    if (!devBranch || !targetBranch) return null;
+
+    return `git push --atomic origin ${devBranch}:${devBranch} ${devBranch}:${targetBranch}`;
+}
+
+function releasePush(context) {
+    const command = getReleasePushCommand(context);
+    if (!command) {
+        logError('❌', 'Не удалось сформировать команду публикации релиза.');
+        return false;
     }
 
-    const addSuccess = execCommand(`git add ${filesToAdd.join(' ')}`);
-    const commitSuccess = execCommand('git commit --message "📝 Обновить changelog и версию." --no-verify');
+    if (!execCommand(command)) {
+        logError(
+            '❌',
+            'Релиз не отправлен в dev и main/master. Убедитесь, что dev содержит актуальный main/master и прямой push разрешен. Повторите: %s',
+            command
+        );
+        return false;
+    }
 
-    if (addSuccess && commitSuccess) {
-        logSuccess('📝', 'Коммит с обновленным changelog и версией создан.');
-        return true;
+    const devBranch = context.devBranch;
+    const targetBranch = context.mainBranch || getMainBranch();
+    logSuccess('📤', 'Релиз атомарно отправлен в origin/%s и origin/%s.', devBranch, targetBranch);
+    return true;
+}
+
+function pushDev(context) {
+    const devBranch = context.devBranch || getCurrentBranch();
+    const command = `git push origin ${devBranch}`;
+    if (!execCommand(command)) {
+        logError('❌', 'Dev-ветка не отправлена. Повторите: %s', command);
+        return false;
     }
-    return false;
+    logSuccess('📤', 'Ветка %s отправлена.', devBranch);
+    return true;
 }
 
 function releaseClose() {
@@ -130,7 +121,9 @@ function releaseClose() {
             { name: 'clean-working-tree', run: requireCleanWorkingTree },
             { name: 'branch-up-to-date', run: requireCurrentBranchUpToDateWithRemote },
             { name: 'on-main-branch', run: requireOnMainBranch },
-            { name: 'main-and-dev-branches', run: requireMainAndDevBranches }
+            { name: 'main-and-dev-branches', run: requireMainAndDevBranches },
+            { name: 'changelog-release-version', run: requireChangelogReleaseVersion },
+            { name: 'stable-tag-at-head', run: (ctx) => requireStableTagAtHead(ctx.version) }
         ],
         steps: [
             { name: 'switch-main', run: () => goToMainBranch() },
@@ -148,17 +141,7 @@ function releaseClose() {
                     return true;
                 }
             },
-            {
-                name: 'push-dev',
-                run: () => {
-                    const currentBranch = getCurrentBranch();
-                    if (!execCommand(`git push origin ${currentBranch} -o ci.skip`)) {
-                        return false;
-                    }
-                    logSuccess('📤', 'Ветка %s отправлена.', currentBranch);
-                    return true;
-                }
-            }
+            { name: 'push-dev', run: pushDev }
         ]
     });
 }
@@ -171,40 +154,44 @@ function releaseStart() {
             { name: 'clean-working-tree', run: requireCleanWorkingTree },
             { name: 'branch-up-to-date', run: requireCurrentBranchUpToDateWithRemote },
             { name: 'main-and-dev-branches', run: requireMainAndDevBranches },
-            { name: 'package-version', run: requirePackageVersion },
             { name: 'on-dev-branch', run: requireOnDevBranch },
-            { name: 'changelog-exists', run: () => requireFileExists('CHANGELOG.md') },
-            { name: 'unreleased-template-exists', run: () => requireFileExists(path.join(__dirname, 'UNRELEASED.md')) },
+            { name: 'stable-version', run: requireLatestStableVersion },
+            { name: 'changelog-exists', run: () => requireFileExists(CHANGELOG_FILE) },
+            { name: 'no-pending-release', run: (ctx) => requireNoPendingRelease(ctx.stableVersion) },
             { name: 'changelog-prettier-check', run: requireChangelogFormatted },
+            { name: 'changelog-fragments', run: requireChangelogFragments },
             {
                 name: 'detect-bump-type',
                 run: (ctx) => {
-                    const bumpType = detectBumpType();
-                    const newVersion = upVersion(ctx.version, bumpType);
-                    const branchCheck = requireReleaseBranchMissing(`release/${newVersion}`);
-                    if (!branchCheck.ok) return branchCheck;
-                    return { ok: true, data: { bumpType, newVersion } };
+                    const resolved = resolveReleaseVersion(ctx.stableVersion, ctx.changelogFragments);
+                    if (!resolved) {
+                        return { ok: false, reason: 'Не удалось вычислить release-версию от последнего стабильного тега.' };
+                    }
+
+                    const versionCheck = requireReleaseVersionAvailable(resolved.newVersion);
+                    if (!versionCheck.ok) return versionCheck;
+                    return { ok: true, data: resolved };
                 }
             }
         ],
         steps: [
-            { name: 'bump-version', run: (ctx) => updateVersionFile(ctx.bumpType) },
-            { name: 'run-install', run: runInstall },
-            { name: 'change-header', run: changelogChangeHeader },
-            { name: 'remove-empty-chapters', run: changelogRemoveEmptyChapters },
-            { name: 'add-unreleased-block', run: changelogAddUnreleasedBlock },
+            { name: 'build-release-changelog', run: changelogBuildRelease },
+            { name: 'remove-changelog-fragments', run: changelogRemoveFragments },
+            { name: 'format-changelog', run: releaseFormatChangelog },
             { name: 'lint-changelog', run: releaseCheckChangelogLint },
-            { name: 'create-release-branch', run: releaseCreate },
             { name: 'commit-release', run: releaseCommit },
-            { name: 'push-release', run: releasePush }
+            { name: 'push-dev-and-main', run: releasePush }
         ]
     });
 }
 
 module.exports = {
-    releaseCreate,
+    getReleasePushCommand,
+    releaseCommit,
     releasePush,
     releaseClose,
     releaseStart,
-    detectBumpType
+    detectBumpType,
+    resolveReleaseVersion,
+    pushDev
 };

package/src/utils.js

@@ -83,15 +83,6 @@ function getPackageManager() {
     return null;
 }
 
-function getVersion() {
-    try {
-        const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
-        return packageJson.version;
-    } catch (error) {
-        return null;
-    }
-}
-
 function getRemoteUrl() {
     const raw = execSilent('git remote get-url origin');
     if (!raw) return null;
@@ -125,7 +116,6 @@ module.exports = {
     getMainBranch,
     getDevelopBranch,
     getPackageManager,
-    getVersion,
     getRemoteUrl,
     getMergeRequestUrl
 };