spectrum-cli 3.1.1 → 4.0.0

package/src/hotfix/checks.js

@@ -0,0 +1,144 @@
+const fs = require('fs');
+const path = require('path');
+const preflight = require('../preflight');
+const { logError } = require('../common/utils');
+const { reportPreflight } = require('../cli/command-executor');
+const { upVersion, compareVersions } = require('../common/version');
+const { STABLE_TAG_PATTERNS, parseStableTag, stableTagNames } = require('../release/stable-tags');
+const { git, exists, ancestor, readAt } = require('./git');
+function preflightReport(commandName) {
+    let failures = 0;
+    return {
+        check(name, action, description, unavailableReason) {
+            if (unavailableReason) {
+                logError('❌', 'Предпроверка не выполнена (%s): %s', name, unavailableReason);
+                failures += 1;
+                return { ok: false };
+            }
+            try {
+                const value = action();
+                reportPreflight(commandName, name, typeof description === 'function' ? description(value) : description);
+                return { ok: true, value };
+            } catch (error) {
+                logError('❌', 'Предпроверка не пройдена (%s): %s', name, error?.message || String(error));
+                failures += 1;
+                return { ok: false };
+            }
+        },
+        get ok() { return failures === 0; }
+    };
+}
+
+function context(mode, checks) {
+    const root = checks.check('repository-root', () => {
+        const root = git('rev-parse', '--show-toplevel').trim();
+        if (path.relative(fs.realpathSync(root), fs.realpathSync(process.cwd())) !== '') {
+            throw new Error('Запустите hotfix из корня репозитория.');
+        }
+    }, 'команда запущена из корня Git-репозитория');
+    const branch = checks.check('branch', () => {
+        const branch = git('branch', '--show-current').trim();
+        if (!['main', 'master'].includes(branch) && !/^hotfix\/.+/.test(branch)) {
+            throw new Error('Hotfix-команды разрешены только на hotfix/*, main или master (не detached HEAD).');
+        }
+        if (mode !== 'start' && !['main', 'master'].includes(branch)) {
+            throw new Error('hotfix deploy/close выполняются на main/master после merge хотфикса.');
+        }
+        if (mode === 'start' && !['main', 'master'].includes(branch) && !/^hotfix\/[A-Z]+-[0-9]+(?:-[A-Za-z0-9][A-Za-z0-9._-]*)?$/.test(branch)) {
+            throw new Error('hotfix start выполняется на hotfix/<TASK>[-slug], main или master.');
+        }
+        return branch;
+    }, (value) => `ветка ${value} разрешена для этой команды`,
+    root.ok ? null : 'не пройдена проверка корня репозитория');
+    if (mode !== 'start') checks.check('clean-working-tree', () => {
+        if (git('status', '--porcelain').trim()) throw new Error('Для deploy/close требуется чистое рабочее дерево.');
+    }, 'рабочее дерево Git чистое', root.ok ? null : 'не пройдена проверка корня репозитория');
+    checks.check('merge-conflicts', () => {
+        if (git('ls-files', '--unmerged').trim()) throw new Error('Сначала разрешите конфликты Git.');
+    }, 'неразрешённых конфликтов Git нет', root.ok ? null : 'не пройдена проверка корня репозитория');
+    let productionRef;
+    const history = checks.check('production-history', () => {
+        git('fetch', 'origin', '--prune', '--tags');
+        const mainBranch = ['master', 'main'].find((name) => exists(`refs/remotes/origin/${name}`));
+        if (!mainBranch) throw new Error('Не найдена production-ветка origin/main или origin/master.');
+        const mainSha = git('rev-parse', `refs/remotes/origin/${mainBranch}`).trim();
+        const head = git('rev-parse', 'HEAD').trim();
+        productionRef = { mainBranch, mainSha, head };
+        if (['main', 'master'].includes(branch.value) && branch.value !== mainBranch) {
+            throw new Error(`Production-ветка origin — ${mainBranch}. Переключитесь на неё или на hotfix/<TASK>[-slug].`);
+        }
+        if (mode === 'start') {
+            if (!ancestor(mainSha, head)) throw new Error('Сначала обновите hotfix из актуальной production-ветки.');
+        } else if (branch.value !== mainBranch || head !== mainSha) {
+            throw new Error(`Нужна ветка ${mainBranch}, точно совпадающая с origin/${mainBranch}.`);
+        }
+        return { mainBranch, mainSha, head };
+    }, (value) => mode === 'start'
+        ? `текущая ветка содержит origin/${value.mainBranch}`
+        : `текущий commit совпадает с origin/${value.mainBranch}`,
+    root.ok && branch.ok ? null : 'не пройдена проверка корня репозитория или ветки');
+    const stable = checks.check('stable-version', () => {
+        const { mainSha } = productionRef;
+        // Query origin explicitly: a local-only tag must never change the baseline.
+        const remoteTags = new Map(git('ls-remote', '--refs', '--tags', 'origin', ...STABLE_TAG_PATTERNS.map((tag) => `refs/tags/${tag}`))
+            .trim().split('\n').filter(Boolean).map((line) => {
+                const [sha, ref] = line.split(/\s+/);
+                return [ref.slice('refs/tags/'.length), sha];
+            }));
+        const versions = git('tag', '--merged', mainSha, '--list', ...STABLE_TAG_PATTERNS).trim().split('\n')
+            .filter((tag) => parseStableTag(tag) && remoteTags.has(tag))
+            .map((tag) => ({ tag, ...parseStableTag(tag) })).sort((a, b) => compareVersions(a.version, b.version));
+        const latest = versions.at(-1);
+        const stable = latest?.version;
+        if (!stable) throw new Error('Для хотфикса необходим опубликованный stable-тег production.');
+        const stableTag = latest.tag;
+        const stableSha = git('rev-parse', `refs/tags/${stableTag}^{commit}`).trim();
+        for (const tag of stableTagNames(stable).filter((name) => remoteTags.has(name))) {
+            if (git('rev-parse', `refs/tags/${tag}^{commit}`).trim() !== stableSha) {
+                throw new Error(`Конфликт stable-тегов версии ${stable}: разные commits.`);
+            }
+        }
+        const productionText = readAt(mainSha);
+        return { remoteTags, stable, stableTag, productionText, target: upVersion(stable, 'patch') };
+    }, (value) => `последний опубликованный stable-тег ${value.stableTag} достижим из production`,
+    productionRef ? null : 'не удалось определить production commit');
+    return { repositoryRootOk: root.ok, ...productionRef, ...history.value, ...stable.value };
+}
+
+function assertTagAvailable(ctx, allowMatchingLocal = false) {
+    for (const tag of stableTagNames(ctx.target)) {
+        if (ctx.remoteTags.has(tag)) throw new Error(`Тег ${tag} уже опубликован; эту версию нельзя выпустить повторно.`);
+        if (exists(`refs/tags/${tag}`) &&
+            (!allowMatchingLocal || tag !== `hotfix/${ctx.target}` || git('rev-parse', `refs/tags/${tag}^{commit}`).trim() !== ctx.head)) {
+            throw new Error(`Локальный тег ${tag} уже существует. Проверьте его перед продолжением.`);
+        }
+    }
+}
+
+function assertOriginUnchanged(ctx) {
+    const line = git('ls-remote', '--heads', 'origin', `refs/heads/${ctx.mainBranch}`).trim();
+    if (line.split(/\s+/)[0] !== ctx.mainSha) {
+        throw new Error('Production изменилась во время проверки. Обновите ветку и повторите команду.');
+    }
+}
+
+function currentFragments() {
+    if (!preflight.findChangelogFragmentFiles().length) return [];
+    const result = preflight.requireChangelogFragments();
+    if (!result.ok) throw new Error(result.reason);
+    return result.data.changelogFragments.map((fragment) => {
+        if (fragment.bump !== 'patch') throw new Error(`Хотфикс не допускает minor/major: ${fragment.filePath}.`);
+        return { ...fragment, content: fs.readFileSync(fragment.filePath, 'utf8') };
+    });
+}
+
+function run(action) {
+    try {
+        return action() !== false;
+    } catch (error) {
+        logError('❌', error.message);
+        return false;
+    }
+}
+
+module.exports = { preflightReport, context, assertTagAvailable, assertOriginUnchanged, currentFragments, run };

package/src/hotfix/close.js

@@ -0,0 +1,46 @@
+const { logSuccess } = require('../common/utils');
+const { isDryRun, reportDryRun } = require('../cli/command-executor');
+const { parseChangelog } = require('../changelog/hotfix');
+const { git, exists, ancestor } = require('./git');
+const { preflightReport, context, assertOriginUnchanged, run } = require('./checks');
+function hotfixClose() {
+    return run(() => {
+        const checks = preflightReport('hotfix close');
+        const ctx = context('close', checks);
+        const tag = `hotfix/${ctx.stable}`;
+        checks.check('stable-tag-at-head', () => {
+            const top = parseChangelog(ctx.productionText).releases[0]?.version;
+            if (top !== ctx.stable || !ctx.remoteTags.has(tag) || git('rev-parse', `refs/tags/${tag}^{commit}`).trim() !== ctx.head) {
+                throw new Error('Сначала опубликуйте hotfix/X.Y.Z на текущем production commit.');
+            }
+        }, `опубликованный тег ${tag} указывает на текущий commit`,
+        ctx.stable && ctx.productionText && ctx.remoteTags && ctx.head ? null : 'не определены stable-тег или production commit');
+        const integration = checks.check('integration-history', () => {
+            const dev = ['develop', 'dev'].find((name) => exists(`refs/remotes/origin/${name}`));
+            if (!dev) throw new Error('Не найдена integration-ветка origin/dev или origin/develop.');
+            const devRef = `refs/remotes/origin/${dev}`;
+            if (exists(`refs/heads/${dev}`) && !ancestor(`refs/heads/${dev}`, devRef)) {
+                throw new Error(`В ${dev} есть локальные непубликуемые commits. Сначала согласуйте их с origin/${dev}.`);
+            }
+            return { dev, devRef };
+        }, (value) => `в локальной ветке ${value.dev} нет неопубликованных коммитов`,
+        ctx.mainBranch ? null : 'не проверена история production');
+        checks.check('origin-unchanged', () => assertOriginUnchanged(ctx),
+            'production-ветка на origin не изменилась во время проверки',
+            ctx.mainBranch && ctx.mainSha ? null : 'не проверена история production');
+        if (!checks.ok) return false;
+        if (isDryRun()) {
+            reportDryRun('hotfix close');
+            return;
+        }
+        const { dev, devRef } = integration.value;
+        if (exists(`refs/heads/${dev}`)) git('switch', dev);
+        else git('switch', '--track', '-c', dev, devRef);
+        git('merge', '--ff-only', devRef);
+        git('merge', '--no-edit', ctx.head);
+        git('push', 'origin', `refs/heads/${dev}:refs/heads/${dev}`);
+        logSuccess('✅', `Хотфикс ${ctx.stable} сведён в ${dev}; production и файлы версий не изменены.`);
+    });
+}
+
+module.exports = { hotfixClose };

package/src/hotfix/deploy.js

@@ -0,0 +1,37 @@
+const { logSuccess } = require('../common/utils');
+const { isDryRun, reportDryRun } = require('../cli/command-executor');
+const { pendingDocument } = require('../changelog/hotfix');
+const { git, exists } = require('./git');
+const { preflightReport, context, assertTagAvailable, assertOriginUnchanged, currentFragments, run } = require('./checks');
+function hotfixDeploy() {
+    return run(() => {
+        const checks = preflightReport('hotfix deploy');
+        const ctx = context('deploy', checks);
+        checks.check('prepared-changelog', () => {
+            const prepared = pendingDocument(ctx.productionText, ctx.target);
+            if (!prepared.pending) throw new Error(`В CHANGELOG.md нужен верхний подготовленный раздел ${ctx.target}.`);
+        }, `верхний раздел CHANGELOG.md содержит хотфикс ${ctx.target}`,
+        ctx.productionText && ctx.target ? null : 'не определены production changelog или версия хотфикса');
+        checks.check('changelog-fragments', () => {
+            if (currentFragments().length) throw new Error('В production остались несобранные hotfix fragments.');
+        }, 'несобранных hotfix fragments нет',
+        ctx.repositoryRootOk ? null : 'не пройдена проверка корня репозитория');
+        checks.check('tag-missing', () => assertTagAvailable(ctx, true),
+            `тег hotfix/${ctx.target} доступен для публикации`,
+            ctx.target ? null : 'не определена целевая версия хотфикса');
+        checks.check('origin-unchanged', () => assertOriginUnchanged(ctx),
+            'production-ветка на origin не изменилась во время проверки',
+            ctx.mainBranch && ctx.mainSha ? null : 'не проверена история production');
+        if (!checks.ok) return false;
+        if (isDryRun()) {
+            reportDryRun('hotfix deploy');
+            return;
+        }
+        const tag = `hotfix/${ctx.target}`;
+        if (!exists(`refs/tags/${tag}`)) git('tag', tag, ctx.head);
+        git('push', 'origin', `refs/tags/${tag}:refs/tags/${tag}`);
+        logSuccess('✅', `Опубликован ${tag} на ${ctx.head}. Дождитесь успешного stable pipeline перед hotfix close.`);
+    });
+}
+
+module.exports = { hotfixDeploy };

package/src/hotfix/git.js

@@ -0,0 +1,35 @@
+const { execFileSync } = require('child_process');
+const { CHANGELOG_FILE } = require('../changelog/config');
+function git(...args) {
+    try {
+        return execFileSync('git', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
+    } catch {
+        throw new Error(`Git не выполнил «${args[0]}». Проверьте доступ к origin, состояние веток и конфликты.`);
+    }
+}
+
+function exists(ref) {
+    try {
+        execFileSync('git', ['show-ref', '--verify', '--quiet', ref], { stdio: 'ignore' });
+        return true;
+    } catch (error) {
+        if (error.status === 1) return false;
+        throw new Error(`Не удалось проверить ref ${ref}.`);
+    }
+}
+
+function ancestor(base, head) {
+    try {
+        execFileSync('git', ['merge-base', '--is-ancestor', base, head], { stdio: 'ignore' });
+        return true;
+    } catch (error) {
+        if (error.status === 1) return false;
+        throw new Error('Не удалось проверить историю Git.');
+    }
+}
+
+function readAt(ref, file = CHANGELOG_FILE) {
+    return git('show', `${ref}:${file}`);
+}
+
+module.exports = { git, exists, ancestor, readAt };

package/src/hotfix/index.js

@@ -0,0 +1,5 @@
+module.exports = {
+    ...require('./start'),
+    ...require('./deploy'),
+    ...require('./close')
+};

package/src/hotfix/start.js

@@ -0,0 +1,57 @@
+const fs = require('fs');
+const preflight = require('../preflight');
+const { execCommand, logSuccess } = require('../common/utils');
+const { isDryRun, reportDryRun } = require('../cli/command-executor');
+const { CHANGELOG_FILE } = require('../changelog/config');
+const { prepareChangelog } = require('../changelog/hotfix');
+const { preflightReport, context, assertTagAvailable, assertOriginUnchanged, currentFragments, run } = require('./checks');
+function formatChangelog() {
+    const runner = preflight.getPrettierRunner();
+    if (!runner || !execCommand(`${runner} --write CHANGELOG.md`) || !execCommand(`${runner} --check CHANGELOG.md`)) {
+        throw new Error('Не удалось отформатировать CHANGELOG.md; hotfix fragments сохранены.');
+    }
+}
+
+function hotfixStart() {
+    return run(() => {
+        const checks = preflightReport('hotfix start');
+        const ctx = context('start', checks);
+        checks.check('tag-missing', () => assertTagAvailable(ctx),
+            `теги версии ${ctx.target} отсутствуют локально и на origin`,
+            ctx.target ? null : 'не определена целевая версия хотфикса');
+        const fragmentsResult = checks.check('changelog-fragments', currentFragments,
+            (value) => `проверены ${value.length} patch fragments`,
+            ctx.repositoryRootOk ? null : 'не пройдена проверка корня репозитория');
+        let original;
+        const changelog = checks.check('changelog-state', () => {
+            original = fs.readFileSync(CHANGELOG_FILE, 'utf8');
+            return prepareChangelog({ text: original, ...ctx, fragments: fragmentsResult.value });
+        }, `CHANGELOG.md допускает подготовку хотфикса ${ctx.target}`,
+        ctx.target && fragmentsResult.ok ? null : 'не определена версия хотфикса или не проверены fragments');
+        checks.check('origin-unchanged', () => assertOriginUnchanged(ctx),
+            'production-ветка на origin не изменилась во время проверки',
+            ctx.mainBranch && ctx.mainSha ? null : 'не проверена история production');
+        if (!checks.ok) return false;
+        const updated = changelog.value;
+        if (isDryRun()) {
+            reportDryRun('hotfix start');
+            return;
+        }
+        if (updated !== original || fragmentsResult.value.length) {
+            try {
+                fs.writeFileSync(CHANGELOG_FILE, updated);
+                formatChangelog();
+                // Validate the formatted current file and keep all merged hotfix notes.
+                prepareChangelog({ text: fs.readFileSync(CHANGELOG_FILE, 'utf8'), ...ctx, fragments: [] });
+                for (const fragment of fragmentsResult.value) fs.unlinkSync(fragment.filePath);
+            } catch (error) {
+                fs.writeFileSync(CHANGELOG_FILE, original);
+                for (const fragment of fragmentsResult.value) fs.writeFileSync(fragment.filePath, fragment.content);
+                throw error;
+            }
+        }
+        logSuccess('✅', `Хотфикс ${ctx.target} подготовлен локально. Проверьте diff и включите CHANGELOG.md и удаления fragments в MR в ${ctx.mainBranch}.`);
+    });
+}
+
+module.exports = { hotfixStart };

package/src/integrations/gitlab-url.js

@@ -0,0 +1,16 @@
+
+function parseGitlabUrl(raw) {
+    const url = new URL(String(raw || '').trim());
+    const pathname = url.pathname.replace(/^\//, '').replace(/\.git$/, '').replace(/\/$/, '');
+    if (!url.origin || !pathname) {
+        throw new Error('invalid gitlab url');
+    }
+    return {
+        origin: url.origin,
+        path: pathname,
+        encodedPath: encodeURIComponent(pathname),
+        url: String(raw).trim()
+    };
+}
+
+module.exports = { parseGitlabUrl };

package/src/preflight/changelog.js

@@ -0,0 +1,130 @@
+const fs = require('fs');
+const path = require('path');
+const { execSilent, execCommand } = require('../common/utils');
+const { CHANGELOG_FILE, CHANGELOG_DIR, FRAGMENT_TYPES, getFragmentType } = require('../changelog/config');
+const { ok, fail, STABLE_SEMVER_PATTERN, toPosixPath } = require('./result');
+function getPrettierRunner() {
+    const npxVersion = execSilent('npx --yes prettier --version');
+    if (npxVersion) return 'npx --yes prettier';
+    const directVersion = execSilent('prettier --version');
+    if (directVersion) return 'prettier';
+    return null;
+}
+
+function requireFileExists(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return fail(`Обязательный файл "${filePath}" не существует.`);
+    }
+    return ok();
+}
+
+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(`Не удалось прочитать версию релиза из ${CHANGELOG_FILE}. Ожидается заголовок "## 🚀 [X.Y.Z]".`);
+    }
+    if (!STABLE_SEMVER_PATTERN.test(version)) {
+        return fail(`Версия "${version}" из ${CHANGELOG_FILE} должна быть стабильным SemVer X.Y.Z.`);
+    }
+    return ok({ version });
+}
+
+function requirePrettierAvailable() {
+    const runner = getPrettierRunner();
+    if (!runner) {
+        return fail('Prettier недоступен.');
+    }
+    return ok({ prettierRunner: runner });
+}
+
+function requireChangelogFormatted() {
+    const runner = getPrettierRunner();
+    if (!runner) {
+        return fail('Prettier недоступен.');
+    }
+    if (!execCommand(`${runner} --check CHANGELOG.md`)) {
+        return fail('Файл CHANGELOG.md не прошел проверку Prettier.');
+    }
+    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 });
+}
+
+module.exports = { getPrettierRunner, requireFileExists, getChangelogReleaseVersions, getChangelogReleaseVersion, requireChangelogReleaseVersion, requirePrettierAvailable, requireChangelogFormatted, findChangelogFragmentFiles, requireChangelogFragments };

package/src/preflight/chart.js

@@ -0,0 +1,57 @@
+const fs = require('fs');
+const path = require('path');
+const { ok, fail, SEMVER_PATTERN, toPosixPath } = require('./result');
+function requireChartChangelogVersion(chartDir) {
+    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 firstHeading = changelog.match(/^##(?!#)[^\r\n]*$/m)?.[0];
+    const version = firstHeading?.match(/^##\s+(?:\S+\s+)?\[([^\]]+)\](?:\s|$)/)?.[1];
+    if (!version || !SEMVER_PATTERN.test(version)) {
+        return fail(`Верхний раздел "${changelogPath}" должен содержать версию SemVer в заголовке "## [X.Y.Z]".`);
+    }
+
+    return ok({ chartChangelogPath: changelogPath, version });
+}
+
+function requireSingleChart() {
+    const chartsDir = 'charts';
+    if (!fs.existsSync(chartsDir)) {
+        return fail('Не удалось найти директорию charts.');
+    }
+
+    const entries = fs.readdirSync(chartsDir, { withFileTypes: true });
+    const chartFiles = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => `${chartsDir}/${entry.name}/Chart.yaml`)
+        .filter((chartFilePath) => fs.existsSync(chartFilePath));
+
+    if (chartFiles.length === 0) {
+        return fail('Не удалось найти Chart.yaml по пути charts/<chart-name>/Chart.yaml.');
+    }
+
+    if (chartFiles.length > 1) {
+        return fail(`Найдено несколько chart-файлов: ${chartFiles.join(', ')}.`);
+    }
+
+    const chartFilePath = chartFiles[0];
+    const chartYaml = fs.readFileSync(chartFilePath, 'utf8');
+    const nameMatch = chartYaml.match(/^\s*name:\s*([^\s#]+)\s*$/m);
+    const chartName = nameMatch ? nameMatch[1] : null;
+    if (!chartName) {
+        return fail(`Не удалось прочитать имя чарта из ${chartFilePath}.`);
+    }
+
+    return ok({ chartFilePath, chartName });
+}
+
+module.exports = { requireChartChangelogVersion, requireSingleChart };