spectrum-cli 3.2.0 → 5.0.0

package/src/changelog/fragments.js

@@ -0,0 +1,223 @@
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+const { logSuccess, logError, execSilent, getCurrentBranch, colors } = require('../common/utils');
+const { CHANGELOG_DIR, FRAGMENT_TYPES, SECTION_TO_TYPE } = require('./config');
+function createReadlineInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+}
+
+function askQuestion(question) {
+    return new Promise((resolve) => {
+        const rl = createReadlineInterface();
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+
+async function extractTaskFromBranch() {
+    const currentBranch = getCurrentBranch();
+    if (!currentBranch) {
+        logError('❌', 'Не удалось получить имя текущей ветки.');
+        return null;
+    }
+
+    const taskMatch = currentBranch.match(/^[a-z][a-z0-9-]*\/([A-Z]+-[0-9]+)(?:-[A-Za-z0-9][A-Za-z0-9._-]*)?$/);
+    if (!taskMatch) {
+        logError(
+            '❌',
+            'Имя ветки "%s" должно соответствовать <type>/<YOUTRACK-ID> или <type>/<YOUTRACK-ID>-<slug>.',
+            currentBranch
+        );
+        return null;
+    }
+
+    return taskMatch[1];
+}
+
+async function getGitUser() {
+    let name = execSilent('git config user.name');
+    let email = execSilent('git config user.email');
+
+    if (!name || !email) {
+        console.log(`⚠️  ${colors.yellow}Имя и email пользователя git не настроены.${colors.reset}`);
+        console.log('💡 Их можно настроить так:');
+        console.log('   git config user.name "Ваше Имя"');
+        console.log('   git config user.email "your.email@domain.com"');
+        console.log('');
+
+        if (!name) {
+            name = await askQuestion('👤 Введите ваше имя: ');
+            if (!name) {
+                logError('❌', 'Имя обязательно.');
+                return null;
+            }
+        }
+
+        if (!email) {
+            email = await askQuestion('📧 Введите ваш email: ');
+            if (!email || !email.includes('@')) {
+                logError('❌', 'Требуется корректный email.');
+                return null;
+            }
+        }
+    }
+
+    return `[${name}](${email})`;
+}
+
+function formatMessage(message) {
+    const trimmedMessage = String(message || '').trim();
+    if (!trimmedMessage) return '';
+    return /[.!?]$/.test(trimmedMessage) ? trimmedMessage : `${trimmedMessage}.`;
+}
+
+function detectSectionFromBranch() {
+    const currentBranch = getCurrentBranch();
+    if (!currentBranch) return [];
+
+    const branchType = currentBranch.split('/', 1)[0].toLowerCase();
+    const sections = {
+        support: [FRAGMENT_TYPES.support.section, FRAGMENT_TYPES.security.section],
+        bugfix: [FRAGMENT_TYPES.fixed.section],
+        feature: [
+            FRAGMENT_TYPES.breaking.section,
+            FRAGMENT_TYPES.added.section,
+            FRAGMENT_TYPES.changed.section,
+            FRAGMENT_TYPES.deprecated.section,
+            FRAGMENT_TYPES.removed.section
+        ]
+    };
+
+    if (branchType === 'support') {
+        return sections.support;
+    }
+    if (branchType === 'bugfix' || branchType === 'fix' || branchType === 'hotfix') {
+        return sections.bugfix;
+    }
+    if (branchType === 'feature' || branchType === 'feat') {
+        return sections.feature;
+    }
+
+    return [];
+}
+
+async function selectSection(availableSections) {
+    const sections = availableSections.length > 0
+        ? availableSections
+        : Object.values(FRAGMENT_TYPES).map((config) => config.section);
+
+    if (sections.length === 1) {
+        return sections[0];
+    }
+
+    console.log('\n📋 Выберите раздел:');
+    sections.forEach((section, index) => {
+        console.log(`   ${index + 1}. ${section}`);
+    });
+
+    const choice = await askQuestion('\n🔢 Введите номер раздела: ');
+    const choiceNum = parseInt(choice, 10);
+
+    if (Number.isNaN(choiceNum) || choiceNum < 1 || choiceNum > sections.length) {
+        logError('❌', 'Неверный выбор.');
+        return null;
+    }
+
+    return sections[choiceNum - 1];
+}
+
+function sanitizeFragmentSlug(branchName, task) {
+    const branchWithoutTask = String(branchName || '').replace(new RegExp(task, 'i'), '-');
+    const slug = branchWithoutTask
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80);
+    return slug || 'change';
+}
+
+function createFragmentPath(task, type, branchName = getCurrentBranch()) {
+    const slug = sanitizeFragmentSlug(branchName, task);
+    return path.posix.join(CHANGELOG_DIR, `${task}-${slug}.${type}.md`);
+}
+
+function displayFragment(fragmentPath, entry) {
+    console.log('\n📝 Changelog fragment создан:');
+    console.log(`   ${colors.green}${fragmentPath}${colors.reset}`);
+    console.log(`   ${colors.green}${entry}${colors.reset}`);
+    console.log('');
+}
+
+async function prepareChangelogEntry(message) {
+    try {
+        const formattedMessage = formatMessage(message);
+        if (!formattedMessage) {
+            return { ok: false, reason: 'Сообщение changelog не может быть пустым.' };
+        }
+
+        const task = await extractTaskFromBranch();
+        if (!task) return { ok: false, reason: 'Не удалось определить ID задачи.' };
+
+        const user = await getGitUser();
+        if (!user) return { ok: false, reason: 'Не удалось определить пользователя git.' };
+
+        const selectedSection = await selectSection(detectSectionFromBranch());
+        if (!selectedSection) return { ok: false, reason: 'Не удалось выбрать раздел.' };
+
+        const type = SECTION_TO_TYPE[selectedSection];
+        if (!type) return { ok: false, reason: `Неизвестный раздел changelog: "${selectedSection}".` };
+
+        return {
+            ok: true,
+            data: {
+                fragmentState: {
+                    entry: `- ${task} ${formattedMessage} ${user}`,
+                    fragmentPath: createFragmentPath(task, type),
+                    selectedSection,
+                    type
+                }
+            }
+        };
+    } catch (error) {
+        return { ok: false, reason: `Ошибка при подготовке changelog fragment: ${error.message}` };
+    }
+}
+
+function appendPreparedChangelogEntry(context) {
+    try {
+        const fragmentState = context.fragmentState;
+        if (!fragmentState) return false;
+
+        fs.mkdirSync(CHANGELOG_DIR, { recursive: true });
+        let entries = [];
+        if (fs.existsSync(fragmentState.fragmentPath)) {
+            entries = fs.readFileSync(fragmentState.fragmentPath, 'utf8')
+                .split('\n')
+                .map((line) => line.trim())
+                .filter(Boolean);
+            if (entries.some((line) => !line.startsWith('- '))) {
+                logError('❌', 'Существующий fragment имеет неверный формат: %s', fragmentState.fragmentPath);
+                return false;
+            }
+        }
+
+        if (!entries.includes(fragmentState.entry)) {
+            entries.push(fragmentState.entry);
+        }
+        fs.writeFileSync(fragmentState.fragmentPath, `${entries.join('\n')}\n`);
+        displayFragment(fragmentState.fragmentPath, fragmentState.entry);
+        logSuccess('✅', 'Запись добавлена в fragment раздела %s', fragmentState.selectedSection);
+        return true;
+    } catch (error) {
+        logError('❌', 'Ошибка при записи changelog fragment: %s', error.message);
+        return false;
+    }
+}
+
+module.exports = { extractTaskFromBranch, getGitUser, formatMessage, detectSectionFromBranch, selectSection, sanitizeFragmentSlug, createFragmentPath, prepareChangelogEntry, appendPreparedChangelogEntry };

package/src/{hotfix-changelog.js → changelog/hotfix.js}

@@ -1,5 +1,5 @@
-const { FRAGMENT_TYPES, SECTION_TO_TYPE } = require('./changelog-config');
-const { renderReleaseBlock } = require('./changelog');
+const { FRAGMENT_TYPES, SECTION_TO_TYPE } = require('./config');
+const { renderReleaseBlock } = require('./index');
 
 // Parse release boundaries without rewriting any published text.
 function parseChangelog(text, { validate = true } = {}) {

package/src/changelog/index.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+module.exports = {
+    ...require('./commands'),
+    ...require('./fragments'),
+    ...require('./format'),
+    ...require('./release-block')
+};

package/src/{open-release.js → changelog/open-release.js}

@@ -1,10 +1,10 @@
 const fs = require('fs');
-const { execSilent, logError, logSuccess } = require('./utils');
-const { compareVersions } = require('./version');
-const { CHANGELOG_FILE, CHANGELOG_DIR } = require('./changelog-config');
-const { parseChangelog, releaseEntries, normalizeLineEndings } = require('./hotfix-changelog');
-const { renderReleaseBlock, stripLegacyUnreleasedBlock } = require('./changelog');
-const { requireChangelogFragments } = require('./preflight');
+const { execSilent, logError, logSuccess } = require('../common/utils');
+const { compareVersions } = require('../common/version');
+const { CHANGELOG_FILE, CHANGELOG_DIR } = require('./config');
+const { parseChangelog, releaseEntries, normalizeLineEndings } = require('./hotfix');
+const { renderReleaseBlock, stripLegacyUnreleasedBlock } = require('./index');
+const { requireChangelogFragments } = require('../preflight');
 
 function splitOpenRelease(text, stableVersion) {
     const document = parseChangelog(stripLegacyUnreleasedBlock(text));

package/src/changelog/release-block.js

@@ -0,0 +1,80 @@
+const fs = require('fs');
+const { logSuccess, logError } = require('../common/utils');
+const { CHANGELOG_FILE, FRAGMENT_TYPES } = require('./config');
+function stripLegacyUnreleasedBlock(changelog) {
+    const unreleasedMatch = /^## \[Unreleased\]\s*$/m.exec(changelog);
+    if (!unreleasedMatch) return changelog;
+
+    const afterUnreleased = unreleasedMatch.index + unreleasedMatch[0].length;
+    const nextHeadingMatch = /^## /m.exec(changelog.slice(afterUnreleased));
+    const end = nextHeadingMatch ? afterUnreleased + nextHeadingMatch.index : changelog.length;
+    return `${changelog.slice(0, unreleasedMatch.index).trimEnd()}\n\n${changelog.slice(end).trimStart()}`;
+}
+
+function renderReleaseBlock(version, fragments, date = new Date().toISOString().slice(0, 10), marker = '🚀') {
+    const fragmentsByType = new Map();
+    for (const fragment of fragments) {
+        const entries = fragmentsByType.get(fragment.type) || [];
+        entries.push(...fragment.entries);
+        fragmentsByType.set(fragment.type, entries);
+    }
+
+    const lines = [`## ${marker ? `${marker} ` : ''}[${version}]${date ? ` - ${date}` : ''}`];
+    for (const [type, config] of Object.entries(FRAGMENT_TYPES)) {
+        const entries = fragmentsByType.get(type);
+        if (!entries || entries.length === 0) continue;
+        lines.push('', config.section, '', ...entries);
+    }
+    return `${lines.join('\n')}\n`;
+}
+
+function insertReleaseBlock(changelog, releaseBlock, version) {
+    const normalized = stripLegacyUnreleasedBlock(changelog).trimEnd();
+    const escapedVersion = String(version).replace(/\./g, '\\.');
+    const versionPattern = new RegExp(`^## 🚀 \\[${escapedVersion}\\](?:\\s|$)`, 'm');
+    if (versionPattern.test(normalized)) {
+        throw new Error(`Версия ${version} уже присутствует в ${CHANGELOG_FILE}.`);
+    }
+
+    const firstReleaseMatch = /^## /m.exec(normalized);
+    if (!firstReleaseMatch) {
+        return `${normalized}\n\n${releaseBlock}`;
+    }
+
+    return `${normalized.slice(0, firstReleaseMatch.index).trimEnd()}\n\n${releaseBlock}\n${normalized.slice(firstReleaseMatch.index).trimStart()}\n`;
+}
+
+function changelogBuildRelease(context, date) {
+    try {
+        const version = context.newVersion;
+        const fragments = context.changelogFragments;
+        if (!version || !Array.isArray(fragments) || fragments.length === 0) return false;
+
+        const changelog = fs.readFileSync(CHANGELOG_FILE, 'utf8');
+        const releaseBlock = renderReleaseBlock(version, fragments, date);
+        const updatedChangelog = insertReleaseBlock(changelog, releaseBlock, version);
+        fs.writeFileSync(CHANGELOG_FILE, updatedChangelog);
+        logSuccess('📋', '%s собран из %s changelog fragments.', `CHANGELOG ${version}`, fragments.length);
+        return true;
+    } catch (error) {
+        logError('❌', 'Не удалось собрать релизный changelog: %s', error.message);
+        return false;
+    }
+}
+
+function changelogRemoveFragments(context) {
+    try {
+        const fragments = context.changelogFragments;
+        if (!Array.isArray(fragments) || fragments.length === 0) return false;
+        for (const fragment of fragments) {
+            fs.unlinkSync(fragment.filePath);
+        }
+        logSuccess('🧹', 'Использованные changelog fragments удалены: %s.', fragments.length);
+        return true;
+    } catch (error) {
+        logError('❌', 'Не удалось удалить changelog fragments: %s', error.message);
+        return false;
+    }
+}
+
+module.exports = { stripLegacyUnreleasedBlock, renderReleaseBlock, insertReleaseBlock, changelogBuildRelease, changelogRemoveFragments };

package/src/chart/deploy.js

@@ -0,0 +1,216 @@
+const readline = require('readline');
+const { logSuccess, logError, execCommand, execSilent } = require('../common/utils');
+const { runCommand } = require('../cli/command-executor');
+const { requireGitRepo, requireCleanWorkingTree, requireOnMainBranch, requireCurrentBranchUpToDateWithRemote, requireRemoteOrigin, requireRemoteReachable, requireSingleChart, requireHelmReleaseFiles } = require('../preflight');
+const { getLatestRemoteChartVersion } = require('./metadata');
+const { fetchChartVersionFromRegistry } = require('./registry');
+const { getInstanceName, parseInstancesOption, updateHelmReleaseVersion, printDeployChanges, splitGitNameOnly } = require('./helmrelease');
+function waitForEnter(promptText) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        rl.question(promptText, () => {
+            rl.close();
+            resolve(true);
+        });
+    });
+}
+
+function chartDeploy(options = {}) {
+    const instancesOption = options.instances;
+
+    return runCommand({
+        name: 'chart deploy',
+        checks: [
+            { name: 'git-repo', run: requireGitRepo },
+            { name: 'clean-working-tree', run: requireCleanWorkingTree },
+            { name: 'on-main-branch', run: requireOnMainBranch },
+            { name: 'branch-up-to-date', run: requireCurrentBranchUpToDateWithRemote },
+            { name: 'remote-origin', run: requireRemoteOrigin },
+            { name: 'remote-reachable', run: requireRemoteReachable },
+            { name: 'single-chart', run: requireSingleChart },
+            { name: 'helmrelease-files', run: requireHelmReleaseFiles },
+            {
+                name: 'filter-instances',
+                run: (ctx) => {
+                    const requested = parseInstancesOption(instancesOption);
+                    if (requested.length === 0) {
+                        return { ok: true };
+                    }
+
+                    const available = new Map();
+                    for (const filePath of ctx.helmReleaseFiles || []) {
+                        const instanceName = getInstanceName(filePath);
+                        if (instanceName) {
+                            available.set(instanceName, filePath);
+                        }
+                    }
+
+                    if (available.size === 0) {
+                        return {
+                            ok: false,
+                            reason: 'В репозитории нет файлов instances/<name>/helmrelease.yaml, флаг --instances неприменим.'
+                        };
+                    }
+
+                    const unknown = requested.filter((name) => !available.has(name));
+                    if (unknown.length > 0) {
+                        return {
+                            ok: false,
+                            reason: `Неизвестные инстансы: ${unknown.join(', ')}. Доступные: ${Array.from(available.keys()).join(', ')}.`
+                        };
+                    }
+
+                    return { ok: true, data: { helmReleaseFiles: requested.map((name) => available.get(name)) } };
+                }
+            }
+        ],
+        steps: [
+            {
+                name: 'resolve-latest-chart-version',
+                run: (ctx) => {
+                    const latestVersion = getLatestRemoteChartVersion(ctx.chartName);
+                    if (!latestVersion) {
+                        logError('❌', 'Не удалось найти удаленный тег чарта для %s.', ctx.chartName);
+                        return false;
+                    }
+                    ctx.latestChartVersion = latestVersion;
+                    logSuccess('🏷️', 'Последняя удаленная версия чарта для %s: %s.', ctx.chartName, latestVersion);
+                    return true;
+                }
+            },
+            {
+                name: 'verify-chart-in-registry',
+                run: async (ctx) => {
+                    const result = await fetchChartVersionFromRegistry(ctx.chartName, ctx.latestChartVersion);
+                    if (!result.ok) {
+                        logError('❌', '%s', result.reason);
+                        return false;
+                    }
+                    if (!result.found) {
+                        logError(
+                            '❌',
+                            'Версия %s чарта %s отсутствует в Helm-registry. Дождитесь пайплайна "upload charts" и повторите.',
+                            ctx.latestChartVersion,
+                            ctx.chartName
+                        );
+                        return false;
+                    }
+                    logSuccess('📦', 'Версия %s чарта %s найдена в Helm-registry.', ctx.latestChartVersion, ctx.chartName);
+                    return true;
+                }
+            },
+            {
+                name: 'update-helmrelease-files',
+                run: (ctx) => {
+                    const changes = (ctx.helmReleaseFiles || []).map((filePath) => updateHelmReleaseVersion(filePath, ctx.latestChartVersion));
+                    ctx.deployChanges = changes;
+                    ctx.updatedFiles = changes.filter((item) => item.changed).map((item) => item.filePath);
+                    ctx.updatedInstances = ctx.updatedFiles.map((filePath) => getInstanceName(filePath) || filePath);
+
+                    printDeployChanges(changes);
+                    if (ctx.updatedFiles.length === 0) {
+                        ctx.noUpdates = true;
+                        logSuccess('✅', 'Все файлы helmrelease.yaml уже используют последнюю версию чарта.');
+                        return true;
+                    }
+
+                    logSuccess('📋', 'Будут обновлены инстансы: %s (версия чарта %s).', ctx.updatedInstances.join(', '), ctx.latestChartVersion);
+                    return true;
+                }
+            },
+            {
+                name: 'confirm-publish',
+                run: async (ctx) => {
+                    if (ctx.noUpdates) {
+                        return true;
+                    }
+                    await waitForEnter('Готов ли ты к публикации? Нажми Enter для продолжения (Ctrl+C для отмены): ');
+                    return true;
+                }
+            },
+            {
+                name: 'commit-and-push',
+                run: (ctx) => {
+                    if (ctx.noUpdates) {
+                        return true;
+                    }
+                    const files = ctx.updatedFiles || [];
+                    const normalizedFiles = files.map((filePath) => String(filePath || '').replace(/\\/g, '/'));
+                    if (files.length === 0) {
+                        logSuccess('✅', 'Файлы не были изменены.');
+                        return true;
+                    }
+
+                    const stagedBeforeAdd = splitGitNameOnly(execSilent('git diff --cached --name-only'));
+                    const unstagedBeforeAdd = splitGitNameOnly(execSilent('git diff --name-only'));
+                    if (stagedBeforeAdd === null || unstagedBeforeAdd === null) {
+                        logError('❌', 'Не удалось проверить измененные файлы перед коммитом.');
+                        return false;
+                    }
+                    if (stagedBeforeAdd.length > 0) {
+                        logError('❌', 'Обнаружены неожиданные изменения в индексе: %s', stagedBeforeAdd.join(', '));
+                        return false;
+                    }
+
+                    const expectedSet = new Set(normalizedFiles);
+                    const unexpectedChanges = unstagedBeforeAdd.filter((filePath) => !expectedSet.has(filePath));
+                    if (unexpectedChanges.length > 0) {
+                        logError('❌', 'Обнаружены неожиданные изменения файлов: %s', unexpectedChanges.join(', '));
+                        return false;
+                    }
+
+                    const missingExpectedChanges = normalizedFiles.filter((filePath) => !unstagedBeforeAdd.includes(filePath));
+                    if (missingExpectedChanges.length > 0) {
+                        logError('❌', 'В diff отсутствуют ожидаемые обновленные файлы: %s', missingExpectedChanges.join(', '));
+                        return false;
+                    }
+
+                    const quoted = normalizedFiles.map((filePath) => `"${filePath}"`).join(' ');
+                    if (!execCommand(`git add ${quoted}`)) {
+                        logError('❌', 'Не удалось добавить обновленные файлы helmrelease.');
+                        return false;
+                    }
+
+                    const stagedAfterAdd = splitGitNameOnly(execSilent('git diff --cached --name-only'));
+                    if (stagedAfterAdd === null) {
+                        logError('❌', 'Не удалось проверить staged-файлы после git add.');
+                        return false;
+                    }
+                    const unexpectedStaged = stagedAfterAdd.filter((filePath) => !expectedSet.has(filePath));
+                    const missingStaged = normalizedFiles.filter((filePath) => !stagedAfterAdd.includes(filePath));
+                    if (unexpectedStaged.length > 0 || missingStaged.length > 0) {
+                        if (unexpectedStaged.length > 0) {
+                            logError('❌', 'Обнаружены неожиданные staged-файлы: %s', unexpectedStaged.join(', '));
+                        }
+                        if (missingStaged.length > 0) {
+                            logError('❌', 'Ожидаемые файлы не добавлены в индекс: %s', missingStaged.join(', '));
+                        }
+                        return false;
+                    }
+
+                    const instanceNames = (ctx.updatedInstances && ctx.updatedInstances.length > 0)
+                        ? ctx.updatedInstances
+                        : normalizedFiles.map((filePath) => getInstanceName(filePath) || filePath);
+                    const versionPart = ctx.latestChartVersion ? ` ${ctx.latestChartVersion}` : '';
+                    const commitMessage = `🚀 Деплой сервиса${versionPart} (${instanceNames.join(', ')}).`;
+                    if (!execCommand(`git commit -m "${commitMessage}"`)) {
+                        logError('❌', 'Не удалось создать коммит деплоя.');
+                        return false;
+                    }
+                    if (!execCommand('git push')) {
+                        logError('❌', 'Не удалось отправить коммит деплоя.');
+                        return false;
+                    }
+
+                    logSuccess('🚀', 'Коммит деплоя отправлен.');
+                    return true;
+                }
+            }
+        ]
+    });
+}
+
+module.exports = { chartDeploy };

package/src/chart/helmrelease.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const { colors } = require('../common/utils');
+const { normalizeList } = require('./routes');
+function getInstanceName(filePath) {
+    const normalized = String(filePath || '').replace(/\\/g, '/');
+    const match = normalized.match(/(?:^|\/)instances\/([^/]+)\/helmrelease\.yaml$/i);
+    return match ? match[1] : null;
+}
+
+function parseInstancesOption(raw) {
+    return normalizeList(String(raw || '').split(','));
+}
+
+function updateHelmReleaseVersion(filePath, nextVersion) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+    const keyStack = [];
+    const oldVersions = [];
+    let changed = false;
+
+    const updatedLines = lines.map((line) => {
+        const keyMatch = line.match(/^(\s*)([A-Za-z0-9_.-]+)\s*:\s*(.*)$/);
+        if (!keyMatch || line.trim().startsWith('#')) {
+            return line;
+        }
+
+        const indent = keyMatch[1].length;
+        const key = keyMatch[2];
+
+        while (keyStack.length > 0 && keyStack[keyStack.length - 1].indent >= indent) {
+            keyStack.pop();
+        }
+
+        const parentPath = keyStack.map((item) => item.key).join('.');
+        keyStack.push({ key, indent });
+        if (!(parentPath === 'spec.chart.spec' && key === 'version')) {
+            return line;
+        }
+
+        const valuePart = keyMatch[3];
+        const valueMatch = valuePart.match(/^(\s*)(['"]?)([^'"#\s]+)\2(\s*(?:#.*)?)$/);
+        if (!valueMatch) {
+            return line;
+        }
+
+        const oldVersion = valueMatch[3];
+        oldVersions.push(oldVersion);
+        if (oldVersion === nextVersion) {
+            return line;
+        }
+
+        changed = true;
+        const spacing = valueMatch[1] || ' ';
+        return `${keyMatch[1]}version:${spacing}${valueMatch[2]}${nextVersion}${valueMatch[2]}${valueMatch[4]}`;
+    });
+
+    if (changed) {
+        fs.writeFileSync(filePath, updatedLines.join('\n'));
+    }
+
+    const uniqueOld = Array.from(new Set(oldVersions));
+    return {
+        filePath,
+        oldVersion: uniqueOld.length > 0 ? uniqueOld.join(', ') : 'unknown',
+        newVersion: nextVersion,
+        changed
+    };
+}
+
+function printDeployChanges(changes) {
+    changes.forEach((item) => {
+        const icon = item.changed ? '●' : '○';
+        const color = item.changed ? colors.green : '\x1b[90m';
+        console.log(
+            `${color}${icon} ${item.filePath}: ${item.oldVersion} -> ${item.newVersion}${colors.reset}`
+        );
+    });
+}
+
+function splitGitNameOnly(output) {
+    if (output === null || output === undefined) {
+        return null;
+    }
+    return String(output)
+        .split('\n')
+        .map((line) => line.trim().replace(/\\/g, '/'))
+        .filter(Boolean);
+}
+
+module.exports = { getInstanceName, parseInstancesOption, updateHelmReleaseVersion, printDeployChanges, splitGitNameOnly };

package/src/chart/index.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+const { chartStart } = require('./start');
+const { chartDeploy } = require('./deploy');
+const { chartVerify, buildGitLikeDiff } = require('./verify');
+const { normalizeList, normalizeToBeList, collectRoutesFromFilesystem, collectRoutesFromBuildArtifacts } = require('./routes');
+const { getChartName, getChartFiles, isSemver, compareSemver, getLatestRemoteChartVersion } = require('./metadata');
+const { helmIndexHasChartVersion, fetchChartVersionFromRegistry, waitForChartInRegistry } = require('./registry');
+const { getInstanceName, parseInstancesOption, updateHelmReleaseVersion } = require('./helmrelease');
+
+module.exports = {
+    chartStart,
+    chartDeploy,
+    chartVerify,
+    normalizeList,
+    normalizeToBeList,
+    collectRoutesFromFilesystem,
+    collectRoutesFromBuildArtifacts,
+    buildGitLikeDiff,
+    getChartName,
+    getChartFiles,
+    isSemver,
+    compareSemver,
+    getLatestRemoteChartVersion,
+    helmIndexHasChartVersion,
+    fetchChartVersionFromRegistry,
+    waitForChartInRegistry,
+    getInstanceName,
+    parseInstancesOption,
+    updateHelmReleaseVersion
+};