spectrum-cli 3.1.1 → 4.0.0

package/src/{changelog.js → changelog/fragments.js}

@@ -1,22 +1,8 @@
-#!/usr/bin/env node
 const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
-const { logSuccess, logError, execSilent, getCurrentBranch, colors } = require('./utils');
-const { runCommand } = require('./command-executor');
-const {
-    requireGitRepo,
-    requireFileExists,
-    requireChangelogFormatted,
-    requireChangelogFragments
-} = require('./preflight');
-const {
-    CHANGELOG_FILE,
-    CHANGELOG_DIR,
-    FRAGMENT_TYPES,
-    SECTION_TO_TYPE
-} = require('./changelog-config');
-
+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,
@@ -234,123 +220,4 @@ function appendPreparedChangelogEntry(context) {
     }
 }
 
-function changelogAppend(message) {
-    return runCommand({
-        name: 'changelog append',
-        checks: [
-            { name: 'git-repo', run: requireGitRepo },
-            { name: 'changelog-exists', run: () => requireFileExists(CHANGELOG_FILE) },
-            { name: 'prepare-fragment', run: () => prepareChangelogEntry(message) }
-        ],
-        steps: [
-            { name: 'write-fragment', run: appendPreparedChangelogEntry }
-        ]
-    });
-}
-
-function changelogCheck() {
-    return runCommand({
-        name: 'changelog check',
-        checks: [
-            { name: 'git-repo', run: requireGitRepo },
-            { name: 'changelog-exists', run: () => requireFileExists(CHANGELOG_FILE) },
-            { name: 'changelog-prettier-check', run: requireChangelogFormatted },
-            { name: 'changelog-fragments', run: requireChangelogFragments }
-        ]
-    });
-}
-
-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 = {
-    changelogAppend,
-    changelogCheck,
-    extractTaskFromBranch,
-    getGitUser,
-    formatMessage,
-    detectSectionFromBranch,
-    selectSection,
-    sanitizeFragmentSlug,
-    createFragmentPath,
-    prepareChangelogEntry,
-    appendPreparedChangelogEntry,
-    stripLegacyUnreleasedBlock,
-    renderReleaseBlock,
-    insertReleaseBlock,
-    changelogBuildRelease,
-    changelogRemoveFragments
-};
+module.exports = { extractTaskFromBranch, getGitUser, formatMessage, detectSectionFromBranch, selectSection, sanitizeFragmentSlug, createFragmentPath, prepareChangelogEntry, appendPreparedChangelogEntry };

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

@@ -1,21 +1,24 @@
-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) {
+function parseChangelog(text, { validate = true } = {}) {
     const headings = [...text.matchAll(/^## .+$/gm)];
     const releases = headings.map((heading, index) => {
         const match = heading[0].match(/^##[ \t]+(?:(🚀|🩹)[ \t]*)?\[(\d+\.\d+\.\d+)\](?:[ \t]+-[ \t]+(\d{4}-\d{2}-\d{2}|\d{4}\.\d{2}\.\d{2}|\d{2}\.\d{2}\.\d{4}))?[ \t]*\r?$/);
         if (!match) {
+            // Production snapshots supply pending notes, not files to validate. Skip
+            // historical non-release sections (including their bodies).
+            if (!validate) return null;
             throw new Error(`Некорректный заголовок CHANGELOG.md: ${heading[0]}. Ожидается ## [X.Y.Z], дата необязательна.`);
         }
-        // Historical duplicates are preserved; callers validate the pending version and immutable history.
+        // Historical duplicates are preserved; callers validate the pending version.
         return {
             version: match[2], date: match[3] || null, marker: match[1] || '',
             text: text.slice(heading.index, headings[index + 1]?.index ?? text.length),
             body: text.slice(heading.index + heading[0].length, headings[index + 1]?.index ?? text.length),
         };
-    });
+    }).filter(Boolean);
     return { intro: text.slice(0, headings[0]?.index ?? text.length), releases };
 }
 
@@ -47,26 +50,18 @@ function normalizeLineEndings(text) {
     return text.replace(/\r\n/g, '\n');
 }
 
-function history(document) {
-    return document.releases.map((release) => normalizeLineEndings(release.text).trim()).join('\n\n');
-}
-
-function pendingDocument(text, stableText, target) {
-    const document = parseChangelog(text);
-    const stable = parseChangelog(stableText);
+function pendingDocument(text, target, { validate = true } = {}) {
+    const document = parseChangelog(text, { validate });
     const pending = document.releases[0]?.version === target ? document.releases.shift() : null;
     if (document.releases.some((release) => release.version === target)) {
         throw new Error('Новый patch-раздел должен быть единственным и находиться в начале CHANGELOG.md.');
     }
-    if (history(document) !== history(stable) || normalizeLineEndings(document.intro).trim() !== normalizeLineEndings(stable.intro).trim()) {
-        throw new Error('История CHANGELOG.md отличается от stable: допустим только верхний раздел следующего patch.');
-    }
     return { document, pending, entries: pending ? releaseEntries(pending, true) : [] };
 }
 
-function prepareChangelog({ text, stableText, productionText, target, fragments, date }) {
-    const current = pendingDocument(text, stableText, target);
-    const production = pendingDocument(productionText, stableText, target);
+function prepareChangelog({ text, productionText, target, fragments, date }) {
+    const current = pendingDocument(text, target);
+    const production = pendingDocument(productionText, target, { validate: false });
     const entryKey = (entry) => `${entry.type}:${entry.entries[0]}`;
     const currentKeys = new Set(current.entries.map(entryKey));
     if (production.entries.some((entry) => !currentKeys.has(entryKey(entry)))) {

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
+};