spectrum-cli 3.2.0 → 4.0.0

package/src/chart.js

@@ -1,1071 +0,0 @@
-#!/usr/bin/env node
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-const readline = require('readline');
-const { logSuccess, logError, execCommand, execSilent, getRemoteUrl, colors } = require('./utils');
-const { runCommand } = require('./command-executor');
-const { parseGitlabUrl } = require('./token');
-const {
-    requireGitRepo,
-    requireCleanWorkingTree,
-    requireOnMainBranch,
-    requireCurrentBranchUpToDateWithRemote,
-    requireRemoteOrigin,
-    requireRemoteReachable,
-    requireSingleChart,
-    requireTagMissing,
-    requireChartChangelogVersion,
-    requireHelmReleaseFiles,
-    requireSingleValuesYaml,
-    requireIngressPathSections,
-    requireSourcePathDirectory,
-    requireNextProject,
-    requireBuildCommandSupport,
-    SEMVER_PATTERN
-} = require('./preflight');
-
-const CHARTS_DIR = 'charts';
-const FIXED_ASSET_PATHS = [
-    '/_next/image$',
-    '/_next/static/media/[a-z0-9_\\.\\-]+\\.(woff|woff2|ttf|otf|eot)$',
-    '/_next/static/chunks/[a-z0-9_\\.\\-]+\\.(css|js)$',
-    '/_next/static/[a-zA-Z0-9_-]+/_ssgManifest.js$',
-    '/_next/static/[a-zA-Z0-9_-]+/_buildManifest.js$',
-    '/_next/static/[a-zA-Z0-9_-]+/_clientMiddlewareManifest.json$',
-    '/[^?]+\\.(?:ico|svg|png|jpg|jpeg|gif|webp|txt|map)$'
-];
-
-function getChartFiles() {
-    try {
-        if (!fs.existsSync(CHARTS_DIR)) {
-            return [];
-        }
-
-        const entries = fs.readdirSync(CHARTS_DIR, { withFileTypes: true });
-        const chartFiles = entries
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => `${CHARTS_DIR}/${entry.name}/Chart.yaml`)
-            .filter((chartFilePath) => fs.existsSync(chartFilePath));
-
-        return chartFiles;
-    } catch (error) {
-        return [];
-    }
-}
-
-function getChartName(chartFilePath) {
-    try {
-        if (!chartFilePath || !fs.existsSync(chartFilePath)) {
-            return null;
-        }
-
-        const chartYaml = fs.readFileSync(chartFilePath, 'utf8');
-        const nameMatch = chartYaml.match(/^\s*name:\s*([^\s#]+)\s*$/m);
-        return nameMatch ? nameMatch[1] : null;
-    } catch (error) {
-        return null;
-    }
-}
-
-function isSemver(version) {
-    return SEMVER_PATTERN.test(version);
-}
-
-function normalizeList(list) {
-    const result = [];
-    const seen = new Set();
-    for (const item of (Array.isArray(list) ? list : [])) {
-        const value = String(item || '').trim();
-        if (!value || seen.has(value)) {
-            continue;
-        }
-        seen.add(value);
-        result.push(value);
-    }
-    return result;
-}
-
-function ensureEndsWithDollar(value) {
-    const text = String(value || '').trim();
-    if (!text) {
-        return '';
-    }
-    return text.endsWith('$') ? text : `${text}$`;
-}
-
-function normalizeToBeList(list) {
-    return normalizeList(list.map(ensureEndsWithDollar));
-}
-
-function segmentToPattern(segment) {
-    if (segment === 'index') {
-        return '';
-    }
-    if (/^\[\[\.\.\..+\]\]$/.test(segment)) {
-        return '.*';
-    }
-    if (/^\[\.\.\..+\]$/.test(segment)) {
-        return '.+';
-    }
-    if (/^\[.+\]$/.test(segment)) {
-        return '[^/]+';
-    }
-    return segment;
-}
-
-function toRouteFromFileSegments(segments) {
-    const transformed = segments.map(segmentToPattern).filter(Boolean);
-    const route = `/${transformed.join('/')}`.replace(/\/+/g, '/');
-    return route === '' ? '/' : route;
-}
-
-function parseApiRouteFromAppFile(filePath) {
-    const rel = filePath.replace(/\\/g, '/').replace(/^app\/api\//, '').replace(/(^|\/)route\.[^.]+$/, '');
-    if (!rel) {
-        return '/api';
-    }
-    return `/api/${toRouteFromFileSegments(rel.split('/')).replace(/^\//, '')}`.replace(/\/+$/, '');
-}
-
-function parseApiRouteFromPagesFile(filePath) {
-    const rel = filePath.replace(/\\/g, '/').replace(/^pages\/api\//, '').replace(/\.[^.]+$/, '');
-    const route = toRouteFromFileSegments(rel.split('/'));
-    return `/api${route === '/' ? '' : route}`.replace(/\/+$/, '') || '/api';
-}
-
-function parsePageRouteFromPagesFile(filePath) {
-    const rel = filePath.replace(/\\/g, '/').replace(/^pages\//, '').replace(/\.[^.]+$/, '');
-    const chunks = rel.split('/').filter(Boolean);
-    const first = chunks[0] || '';
-    const excludedFiles = new Set(['_app', '_document', '_error', '404', '500']);
-    if (first === 'api' || excludedFiles.has(first)) {
-        return null;
-    }
-    return toRouteFromFileSegments(chunks);
-}
-
-function parsePageRouteFromAppFile(filePath) {
-    const rel = filePath.replace(/\\/g, '/').replace(/^app\//, '').replace(/(^|\/)page\.[^.]+$/, '');
-    if (rel.startsWith('api/')) {
-        return null;
-    }
-    if (!rel) {
-        return '/';
-    }
-    const chunks = rel
-        .split('/')
-        .filter(Boolean)
-        .filter((part) => !/^\(.+\)$/.test(part) && !part.startsWith('@'));
-    return toRouteFromFileSegments(chunks);
-}
-
-function collectFilesRecursively(dirPath, matcher) {
-    if (!fs.existsSync(dirPath)) {
-        return [];
-    }
-
-    const stack = [dirPath];
-    const found = [];
-    while (stack.length > 0) {
-        const current = stack.pop();
-        let entries = [];
-        try {
-            entries = fs.readdirSync(current, { withFileTypes: true });
-        } catch (error) {
-            return found;
-        }
-
-        for (const entry of entries) {
-            const fullPath = path.join(current, entry.name);
-            if (entry.isDirectory()) {
-                stack.push(fullPath);
-                continue;
-            }
-            if (entry.isFile() && matcher(fullPath)) {
-                found.push(fullPath);
-            }
-        }
-    }
-    return found;
-}
-
-function collectRoutesFromFilesystem(sourcePath) {
-    const api = [];
-    const pages = [];
-    const appDirCandidates = [path.join(sourcePath, 'app'), path.join(sourcePath, 'src', 'app')];
-    const pagesDirCandidates = [path.join(sourcePath, 'pages'), path.join(sourcePath, 'src', 'pages')];
-
-    for (const appDir of appDirCandidates) {
-        const appApiFiles = collectFilesRecursively(
-            path.join(appDir, 'api'),
-            (file) => /[\\/]route\.(js|jsx|ts|tsx|mjs|cjs)$/.test(file)
-        );
-        for (const absFile of appApiFiles) {
-            const rel = path.relative(path.join(appDir, 'api'), absFile).replace(/\\/g, '/');
-            api.push(parseApiRouteFromAppFile(`app/api/${rel}`));
-        }
-
-        const appPageFiles = collectFilesRecursively(appDir, (file) => /[\\/]page\.(js|jsx|ts|tsx|mdx)$/.test(file));
-        for (const absFile of appPageFiles) {
-            const rel = path.relative(appDir, absFile).replace(/\\/g, '/');
-            const route = parsePageRouteFromAppFile(`app/${rel}`);
-            if (route) {
-                pages.push(route);
-            }
-        }
-    }
-
-    for (const pagesDir of pagesDirCandidates) {
-        const pagesApiFiles = collectFilesRecursively(path.join(pagesDir, 'api'), (file) => /\.(js|jsx|ts|tsx|mjs|cjs)$/.test(file));
-        for (const absFile of pagesApiFiles) {
-            const rel = path.relative(path.join(pagesDir, 'api'), absFile).replace(/\\/g, '/');
-            api.push(parseApiRouteFromPagesFile(`pages/api/${rel}`));
-        }
-
-        const pagesFiles = collectFilesRecursively(pagesDir, (file) => /\.(js|jsx|ts|tsx|mdx)$/.test(file));
-        for (const absFile of pagesFiles) {
-            const rel = path.relative(pagesDir, absFile).replace(/\\/g, '/');
-            const route = parsePageRouteFromPagesFile(`pages/${rel}`);
-            if (route) {
-                pages.push(route);
-            }
-        }
-    }
-
-    return {
-        api: normalizeList(api),
-        pages: normalizeList(pages)
-    };
-}
-
-function readJsonIfExists(filePath) {
-    if (!fs.existsSync(filePath)) {
-        return null;
-    }
-    try {
-        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    } catch (error) {
-        return null;
-    }
-}
-
-function collectRoutesFromBuildArtifacts(sourcePath) {
-    const api = [];
-    const pages = [];
-
-    const routesManifest = readJsonIfExists(path.join(sourcePath, '.next', 'routes-manifest.json'));
-    if (routesManifest) {
-        const combined = []
-            .concat(routesManifest.staticRoutes || [])
-            .concat(routesManifest.dynamicRoutes || [])
-            .concat(routesManifest.dataRoutes || []);
-        for (const routeInfo of combined) {
-            const route = routeInfo.page || routeInfo.pathname || routeInfo.route;
-            if (!route || typeof route !== 'string') {
-                continue;
-            }
-            if (route.startsWith('/api')) {
-                api.push(route);
-            } else {
-                pages.push(route);
-            }
-        }
-    }
-
-    const appRoutesManifest = readJsonIfExists(path.join(sourcePath, '.next', 'server', 'app-path-routes-manifest.json'))
-        || readJsonIfExists(path.join(sourcePath, '.next', 'server', 'app-paths-manifest.json'))
-        || readJsonIfExists(path.join(sourcePath, '.next', 'app-path-routes-manifest.json'));
-    if (appRoutesManifest && typeof appRoutesManifest === 'object') {
-        Object.entries(appRoutesManifest).forEach(([key, routeValue]) => {
-            const route = typeof routeValue === 'string' ? routeValue : key;
-            if (typeof route !== 'string') {
-                return;
-            }
-            if (route.startsWith('/_')) {
-                return;
-            }
-            if (route.startsWith('/api')) {
-                api.push(route);
-            } else {
-                pages.push(route);
-            }
-        });
-    }
-
-    const pagesManifest = readJsonIfExists(path.join(sourcePath, '.next', 'server', 'pages-manifest.json'));
-    if (pagesManifest && typeof pagesManifest === 'object') {
-        Object.keys(pagesManifest).forEach((route) => {
-            if (route === '/_app' || route === '/_document' || route === '/_error' || route === '/404' || route === '/500') {
-                return;
-            }
-            if (route.startsWith('/api')) {
-                api.push(route);
-            } else {
-                pages.push(route);
-            }
-        });
-    }
-
-    return {
-        api: normalizeList(api),
-        pages: normalizeList(pages)
-    };
-}
-
-function runBuildInSourcePath(sourcePath, packageManager) {
-    const manager = packageManager || 'npm';
-    const hasNodeModules = fs.existsSync(path.join(sourcePath, 'node_modules'));
-    const hasPackageLock = fs.existsSync(path.join(sourcePath, 'package-lock.json'));
-    const hasYarnLock = fs.existsSync(path.join(sourcePath, 'yarn.lock'));
-    const hasBunLock = fs.existsSync(path.join(sourcePath, 'bun.lockb'));
-    const installCommand = manager === 'yarn'
-        ? (hasYarnLock ? 'yarn install --frozen-lockfile' : 'yarn install')
-        : manager === 'bun'
-            ? 'bun install'
-            : (hasPackageLock ? 'npm ci' : 'npm install');
-    const buildCommand = manager === 'yarn' ? 'yarn build' : manager === 'bun' ? 'bun run build' : 'npm run build';
-
-    try {
-        if (!hasNodeModules) {
-            execSync(installCommand, { cwd: sourcePath, stdio: 'pipe', timeout: 600000 });
-        } else if (!hasPackageLock && !hasYarnLock && !hasBunLock) {
-            execSync(installCommand, { cwd: sourcePath, stdio: 'pipe', timeout: 600000 });
-        }
-
-        execSync(buildCommand, { cwd: sourcePath, stdio: 'pipe', timeout: 900000 });
-        return true;
-    } catch (error) {
-        return false;
-    }
-}
-
-function buildGitLikeDiff(asIsList, toBeList, title) {
-    const asIs = normalizeList(asIsList);
-    const toBe = normalizeList(toBeList);
-    const asIsSet = new Set(asIs);
-    const toBeSet = new Set(toBe);
-    const removed = asIs.filter((item) => !toBeSet.has(item));
-    const added = toBe.filter((item) => !asIsSet.has(item));
-    const unchanged = asIs.filter((item) => toBeSet.has(item));
-
-    const lines = [
-        `--- AS_IS/${title}`,
-        `+++ TO_BE/${title}`,
-        `@@ ${title} @@`
-    ];
-    removed.forEach((item) => lines.push(`-${item}`));
-    added.forEach((item) => lines.push(`+${item}`));
-    if (removed.length === 0 && added.length === 0) {
-        lines.push('  (no changes)');
-    }
-
-    return {
-        removed,
-        added,
-        unchanged,
-        text: lines.join('\n')
-    };
-}
-
-function printSection(title, asIsList, toBeList) {
-    const asIs = normalizeList(asIsList);
-    const toBe = normalizeList(toBeList);
-    const diff = buildGitLikeDiff(asIs, toBe, title);
-
-    console.log(`\nСравнение путей ${title} (КАК ЕСТЬ -> КАК ДОЛЖНО БЫТЬ):`);
-    console.log(`--- AS_IS/${title}`);
-    console.log(`+++ TO_BE/${title}`);
-    console.log(`@@ ${title} @@`);
-    if (diff.removed.length === 0 && diff.added.length === 0) {
-        console.log('  (без изменений)');
-    } else {
-        diff.removed.forEach((item) => console.log(`${colors.yellow}-${item}${colors.reset}`));
-        diff.added.forEach((item) => console.log(`${colors.red}+${item}${colors.reset}`));
-    }
-    console.log(`${title} сводка: добавлено=${diff.added.length}, удалено=${diff.removed.length}, без изменений=${diff.unchanged.length}`);
-
-    return diff;
-}
-
-function chartVerify(sourcePath) {
-    return runCommand({
-        name: 'chart verify',
-        checks: [
-            { name: 'git-repo', run: requireGitRepo },
-            { name: 'branch-up-to-date', run: requireCurrentBranchUpToDateWithRemote },
-            { name: 'single-values-yaml', run: requireSingleValuesYaml },
-            { name: 'values-ingress-sections', run: (ctx) => requireIngressPathSections(ctx.valuesYamlPath) },
-            { name: 'source-path-directory', run: () => requireSourcePathDirectory(sourcePath) },
-            { name: 'next-project', run: (ctx) => requireNextProject(ctx.sourcePath) },
-            { name: 'build-command-support', run: (ctx) => requireBuildCommandSupport(ctx.sourcePath) }
-        ],
-        steps: [
-            {
-                name: 'collect-routes',
-                run: (ctx) => {
-                    const fromBuild = collectRoutesFromBuildArtifacts(ctx.sourcePath);
-                    let api = normalizeList(fromBuild.api);
-                    let pages = normalizeList(fromBuild.pages);
-
-                    if (api.length === 0 || pages.length === 0) {
-                        const didBuild = runBuildInSourcePath(ctx.sourcePath, ctx.sourcePackageManager);
-                        if (didBuild) {
-                            logSuccess('🛠️', 'Сборка успешно завершена в %s.', ctx.sourcePath);
-                            const rebuilt = collectRoutesFromBuildArtifacts(ctx.sourcePath);
-                            api = normalizeList(api.concat(rebuilt.api));
-                            pages = normalizeList(pages.concat(rebuilt.pages));
-                        } else {
-                            logError('⚠️', 'Сборка в %s не удалась. Переходим к маршрутам из файловой системы.', ctx.sourcePath);
-                        }
-                    }
-
-                    const fromFs = collectRoutesFromFilesystem(ctx.sourcePath);
-                    api = normalizeList(api.concat(fromFs.api));
-                    pages = normalizeList(pages.concat(fromFs.pages));
-
-                    ctx.toBeIngressPaths = {
-                        api: normalizeToBeList(api),
-                        pages: normalizeToBeList(pages),
-                        assets: normalizeToBeList(FIXED_ASSET_PATHS)
-                    };
-                    return true;
-                }
-            },
-            {
-                name: 'compare-and-report',
-                run: (ctx) => {
-                    const asIs = ctx.valuesIngressPaths || { api: [], pages: [], assets: [] };
-                    const toBe = ctx.toBeIngressPaths || { api: [], pages: [], assets: [] };
-
-                    const apiDiff = printSection('api', asIs.api, toBe.api);
-                    const pagesDiff = printSection('pages', asIs.pages, toBe.pages);
-                    const assetsDiff = printSection('assets', asIs.assets, toBe.assets);
-
-                    const hasChanges = (
-                        apiDiff.added.length + apiDiff.removed.length +
-                        pagesDiff.added.length + pagesDiff.removed.length +
-                        assetsDiff.added.length + assetsDiff.removed.length
-                    ) > 0;
-
-                    if (hasChanges) {
-                        logError('❌', '[chart verify] Обнаружены различия.');
-                        return false;
-                    }
-
-                    logSuccess('✅', '[chart verify] КАК ЕСТЬ совпадает с КАК ДОЛЖНО БЫТЬ.');
-                    return true;
-                }
-            }
-        ]
-    });
-}
-
-function chartCreateTag(version, options = {}) {
-    const force = Boolean(options.force);
-    const wait = Boolean(options.wait);
-
-    return runCommand({
-        name: 'chart create',
-        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: 'valid-semver',
-                run: () => {
-                    if (!isSemver(version)) {
-                        return { ok: false, reason: `Версия "${version}" не соответствует semver.` };
-                    }
-                    return { ok: true, data: { version } };
-                }
-            },
-            { name: 'single-chart', run: requireSingleChart },
-            {
-                name: 'chart-changelog-version',
-                run: (ctx) => requireChartChangelogVersion(path.dirname(ctx.chartFilePath), ctx.version)
-            },
-            {
-                name: 'version-not-downgrade',
-                run: (ctx) => {
-                    const latestVersion = getLatestRemoteChartVersion(ctx.chartName);
-                    if (!latestVersion) {
-                        return { ok: true };
-                    }
-                    if (compareSemver(ctx.version, latestVersion) > 0) {
-                        return { ok: true, data: { latestChartVersion: latestVersion } };
-                    }
-                    if (force) {
-                        logError('⚠️', 'Версия %s не больше последней опубликованной %s. Продолжаю из-за --force.', ctx.version, latestVersion);
-                        return { ok: true, data: { latestChartVersion: latestVersion } };
-                    }
-                    return {
-                        ok: false,
-                        reason: `Версия "${ctx.version}" не больше последней опубликованной "${latestVersion}". Для сознательного отката используйте --force.`
-                    };
-                }
-            },
-            {
-                name: 'tag-missing',
-                run: (ctx) => requireTagMissing(`chart-${ctx.chartName}-${ctx.version}`)
-            }
-        ],
-        steps: [
-            {
-                name: 'create-tag',
-                run: (ctx) => {
-                    const tagName = `chart-${ctx.chartName}-${ctx.version}`;
-                    if (!execCommand(`git tag "${tagName}"`)) {
-                        logError('❌', 'Не удалось создать тег %s.', tagName);
-                        return false;
-                    }
-                    logSuccess('🔖', 'Создан тег %s.', tagName);
-                    return true;
-                }
-            },
-            {
-                name: 'push-tag',
-                run: (ctx) => {
-                    const tagName = `chart-${ctx.chartName}-${ctx.version}`;
-                    if (!execCommand(`git push origin "${tagName}"`)) {
-                        logError('❌', 'Не удалось отправить тег %s в origin.', tagName);
-                        return false;
-                    }
-                    logSuccess('🚀', 'Тег %s отправлен в origin.', tagName);
-                    return true;
-                }
-            },
-            ...(wait
-                ? [{
-                    name: 'wait-for-registry',
-                    run: (ctx) => waitForChartInRegistry(ctx.chartName, ctx.version)
-                }]
-                : [])
-        ]
-    });
-}
-
-function compareSemver(a, b) {
-    const parse = (value) => {
-        const [rawMain, rawMeta] = String(value || '').split('+', 2);
-        const [rawVersion, rawPre] = rawMain.split('-', 2);
-        const versionParts = rawVersion.split('.').map((part) => Number(part));
-        const preParts = rawPre ? rawPre.split('.') : [];
-        return { versionParts, preParts, hasPre: Boolean(rawPre), meta: rawMeta || '' };
-    };
-    const pa = parse(a);
-    const pb = parse(b);
-
-    for (let i = 0; i < 3; i += 1) {
-        const diff = (pa.versionParts[i] || 0) - (pb.versionParts[i] || 0);
-        if (diff !== 0) return diff;
-    }
-
-    if (pa.hasPre && !pb.hasPre) return -1;
-    if (!pa.hasPre && pb.hasPre) return 1;
-    if (!pa.hasPre && !pb.hasPre) return 0;
-
-    const len = Math.max(pa.preParts.length, pb.preParts.length);
-    for (let i = 0; i < len; i += 1) {
-        const aa = pa.preParts[i];
-        const bb = pb.preParts[i];
-        if (aa === undefined) return -1;
-        if (bb === undefined) return 1;
-        const aNum = /^\d+$/.test(aa);
-        const bNum = /^\d+$/.test(bb);
-        if (aNum && bNum) {
-            const diff = Number(aa) - Number(bb);
-            if (diff !== 0) return diff;
-            continue;
-        }
-        if (aNum && !bNum) return -1;
-        if (!aNum && bNum) return 1;
-        if (aa < bb) return -1;
-        if (aa > bb) return 1;
-    }
-
-    return 0;
-}
-
-function getLatestRemoteChartVersion(chartName) {
-    const safeChartName = String(chartName || '').trim();
-    if (!safeChartName) return null;
-
-    const prefix = `chart-${safeChartName}-`;
-    let output = '';
-    try {
-        output = execSync(`git ls-remote --tags origin "refs/tags/${prefix}*"`, { stdio: 'pipe', encoding: 'utf8' });
-    } catch (error) {
-        return null;
-    }
-
-    const versions = String(output || '')
-        .split('\n')
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .map((line) => line.split(/\s+/)[1] || '')
-        .map((ref) => ref.replace('refs/tags/', ''))
-        .filter((tag) => tag.startsWith(prefix))
-        .map((tag) => tag.slice(prefix.length))
-        .filter((version) => isSemver(version));
-
-    if (versions.length === 0) {
-        return null;
-    }
-
-    versions.sort(compareSemver);
-    return versions[versions.length - 1];
-}
-
-const HELM_REGISTRY_CHANNEL = 'stable';
-const REGISTRY_WAIT_TIMEOUT_MS = 10 * 60 * 1000;
-const REGISTRY_WAIT_INTERVAL_MS = 15 * 1000;
-
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function getGitlabProject() {
-    const baseUrl = getRemoteUrl();
-    if (!baseUrl) {
-        return null;
-    }
-    try {
-        return parseGitlabUrl(baseUrl);
-    } catch (error) {
-        return null;
-    }
-}
-
-function helmIndexHasChartVersion(indexYamlContent, chartName, version) {
-    const escapedChartName = String(chartName || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const chartHeadingPattern = new RegExp(`^${escapedChartName}:\\s*(#.*)?$`);
-    const lines = String(indexYamlContent || '').split('\n');
-    let inEntries = false;
-    let inChart = false;
-    let entriesIndent = 0;
-    let chartIndent = 0;
-
-    for (const rawLine of lines) {
-        const line = rawLine.replace(/\r$/, '');
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#')) {
-            continue;
-        }
-
-        const indent = line.match(/^\s*/)[0].length;
-
-        if (/^entries:\s*(#.*)?$/.test(trimmed) && indent === 0) {
-            inEntries = true;
-            inChart = false;
-            entriesIndent = indent;
-            continue;
-        }
-
-        if (inEntries && indent <= entriesIndent) {
-            inEntries = false;
-            inChart = false;
-        }
-
-        if (!inEntries) {
-            continue;
-        }
-
-        if (chartHeadingPattern.test(trimmed)) {
-            inChart = true;
-            chartIndent = indent;
-            continue;
-        }
-
-        if (inChart && indent <= chartIndent) {
-            inChart = false;
-        }
-
-        if (!inChart) {
-            continue;
-        }
-
-        const versionMatch = trimmed.match(/^-?\s*version:\s*["']?([^"'\s#]+)["']?\s*(#.*)?$/);
-        if (versionMatch && versionMatch[1] === String(version)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-async function fetchChartVersionFromRegistry(chartName, version) {
-    const project = getGitlabProject();
-    if (!project) {
-        return { ok: false, reason: 'Не удалось определить GitLab-проект из remote "origin".' };
-    }
-
-    const accessToken = process.env.GITLAB_PRIVATE_TOKEN;
-    if (!accessToken) {
-        return {
-            ok: false,
-            reason: 'Не задана переменная окружения GITLAB_PRIVATE_TOKEN. Она нужна для проверки публикации чарта в Helm-registry.'
-        };
-    }
-
-    const indexUrl = `${project.origin}/api/v4/projects/${project.encodedPath}/packages/helm/${HELM_REGISTRY_CHANNEL}/index.yaml`;
-    let response;
-    try {
-        response = await fetch(indexUrl, { headers: { 'PRIVATE-TOKEN': accessToken } });
-    } catch (error) {
-        return { ok: false, reason: `Не удалось запросить Helm-registry (${indexUrl}): ${error.message}.` };
-    }
-
-    if (!response.ok) {
-        return { ok: false, reason: `Helm-registry вернул HTTP ${response.status} (${indexUrl}).` };
-    }
-
-    const indexYaml = await response.text();
-    return {
-        ok: true,
-        found: helmIndexHasChartVersion(indexYaml, chartName, version),
-        indexUrl
-    };
-}
-
-async function waitForChartInRegistry(chartName, version, options = {}) {
-    const timeoutMs = options.timeoutMs === undefined ? REGISTRY_WAIT_TIMEOUT_MS : options.timeoutMs;
-    const intervalMs = options.intervalMs === undefined ? REGISTRY_WAIT_INTERVAL_MS : options.intervalMs;
-    const sleepFn = options.sleep || sleep;
-    const deadline = Date.now() + timeoutMs;
-
-    while (true) {
-        const result = await fetchChartVersionFromRegistry(chartName, version);
-        if (!result.ok) {
-            logError('❌', '%s', result.reason);
-            return false;
-        }
-        if (result.found) {
-            logSuccess('📦', 'Версия %s чарта %s опубликована в Helm-registry.', version, chartName);
-            return true;
-        }
-        if (Date.now() >= deadline) {
-            logError('❌', 'Версия %s чарта %s не появилась в Helm-registry за отведенное время.', version, chartName);
-            return false;
-        }
-        logSuccess('⏳', 'Версия %s чарта %s еще не опубликована, продолжаю ожидание...', version, chartName);
-        await sleepFn(intervalMs);
-    }
-}
-
-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 waitForEnter(promptText) {
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        rl.question(promptText, () => {
-            rl.close();
-            resolve(true);
-        });
-    });
-}
-
-function splitGitNameOnly(output) {
-    if (output === null || output === undefined) {
-        return null;
-    }
-    return String(output)
-        .split('\n')
-        .map((line) => line.trim().replace(/\\/g, '/'))
-        .filter(Boolean);
-}
-
-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 = {
-    chartCreateTag,
-    chartDeploy,
-    chartVerify,
-    normalizeList,
-    normalizeToBeList,
-    collectRoutesFromFilesystem,
-    collectRoutesFromBuildArtifacts,
-    buildGitLikeDiff,
-    getChartName,
-    getChartFiles,
-    isSemver,
-    compareSemver,
-    getLatestRemoteChartVersion,
-    helmIndexHasChartVersion,
-    fetchChartVersionFromRegistry,
-    waitForChartInRegistry,
-    getInstanceName,
-    parseInstancesOption,
-    updateHelmReleaseVersion
-};