@mirta/cli 0.3.5 → 0.4.0

package/dist/release.mjs

@@ -1,195 +1,295 @@
-import { parseArgs } from 'node:util';
-import { prerelease, inc, valid } from 'semver';
-import { h as helpMessage, g as getCurrentVersion, u as updateVersion, a as hasScript } from './package.mjs';
-import { c as checkIsInWorkTreeAsync, g as getRepositoryDetails, b as assertIsSyncedWithRemoteAsync, p as prompts, d as assertWorkflowResultAsync } from './github.mjs';
-import { g as getLocalized, u as useLogger, r as runCommandAsync } from './shell.mjs';
+import { u as updateVersion, h as hasScript, g as getCurrentVersion } from './package.mjs';
+import { inc, valid, prerelease } from 'semver';
+import { a as assertNoParseErrors, l as logger, p as prompts, g as getRepositoryDetails, b as assertIsSyncedWithRemoteAsync, c as assertWorkflowResultAsync, r as runCommandAsync, t, d as checkIsInWorkTreeAsync } from './index.mjs';
 import chalk from 'chalk';
-import cliPackage from '../package.json' with { type: 'json' };
+import { r as resolveConfigAsync } from './resolve.mjs';
 import 'node:path';
-import 'node:fs';
+import 'p-map';
+import 'node:fs/promises';
+import '@mirta/workspace';
+import '@mirta/package';
+import './constants.mjs';
 import 'prompts';
+import '@mirta/staged-args';
 import 'node:child_process';
-import 'node:url';
-import 'lodash.merge';
+import '@mirta/i18n';
+import '../package.json' with { type: 'json' };
+import '@mirta/basics/fuzzy';
+import 'node:os';
+import 'node:path/posix';
+import 'jsonc-parser';
+import '@mirta/basics/object';
 
-const { yellow } = chalk;
-const allOptions = ({
-    dry: {
+const options = ({
+    'config': {
+        type: 'string',
+        short: 'c',
+    },
+    'dry-run': {
         type: 'boolean',
-        default: false,
     },
-    preid: {
+    'preid': {
         type: 'string',
     },
-    skipPrompts: {
+    'skip-git': {
         type: 'boolean',
-        default: false,
     },
-    skipGit: {
+    'skip-prompts': {
         type: 'boolean',
-        default: false,
     },
-    skipBuild: {
+    // Deprecated. Use 'skip-git' instead
+    'skipGit': {
         type: 'boolean',
-        default: false,
     },
-    help: {
+    // Deprecated. Use 'skip-prompts' instead
+    'skipPrompts': {
         type: 'boolean',
-        short: 'h',
-        default: false,
     },
-    version: {
+    // Deprecated. Use 'dry-run' instead
+    'dry': {
         type: 'boolean',
-        short: 'v',
-        default: false,
     },
 });
-const args = process.argv.slice(2);
-const { values: argv, positionals } = parseArgs({
-    args,
-    options: allOptions,
-    allowPositionals: true,
-});
-if (argv.help) {
-    console.log(helpMessage);
-    process.exit(0);
+function parseArgs(args) {
+    const parseResult = args.parseFinal(options);
+    assertNoParseErrors(parseResult);
+    const { values, positionals } = parseResult.data;
+    if (values.dry) {
+        logger.warn('Deprecated flag "--dry" used. Please use "--dry-run" instead');
+        values['dry-run'] = values['dry-run'] !== false;
+    }
+    if (values.skipGit) {
+        logger.warn('Deprecated flag "--skipGit" used. Please use "--skip-git" instead');
+        values['skip-git'] = values['skip-git'] !== false;
+    }
+    if (values.skipPrompts) {
+        logger.warn('Deprecated flag "--skipPrompts" used. Please use "--skip-prompts" instead');
+        values['skip-prompts'] = values['skip-prompts'] !== false;
+    }
+    return {
+        values,
+        positionals,
+    };
 }
-if (argv.version) {
-    console.log(`${cliPackage.name} v${cliPackage.version}`);
-    process.exit(0);
+
+function getReleaseTypes(preid) {
+    const releaseTypes = [
+        'patch',
+        'minor',
+        'major',
+        ...(preid
+            ? (['prepatch', 'preminor', 'premajor', 'prerelease'])
+            : []),
+    ];
+    return releaseTypes;
 }
-const messages = await getLocalized();
-const logger = useLogger(messages);
-const currentVersion = getCurrentVersion();
-const preid = argv.preid ?? prerelease(currentVersion)?.[0];
-/** Возможные типы релиза. */
-const releaseTypes = [
-    'patch',
-    'minor',
-    'major',
-    ...(preid
-        ? (['prepatch', 'preminor', 'premajor', 'prerelease'])
-        : []),
-];
-const isDryRun = argv.dry;
-const skipGit = argv.skipGit;
-const skipPrompts = argv.skipPrompts;
-// Параметр командной строки:
-// конкретный номер версии, либо тип релиза (см. releaseTypes).
-//
-let targetVersion = positionals[1];
-const getIncremented = (release) => inc(currentVersion, release, void 0, preid);
-const inWorkTree = await checkIsInWorkTreeAsync();
-let repository;
-let connectionType;
-if (inWorkTree) {
-    const { name: repoName, connectionType: connType } = await getRepositoryDetails();
-    // Репозиторий, в котором выполняется релиз.
-    repository = repoName;
-    // Тип подключения к удалённому репозиторию.
-    connectionType = connType;
-    if (repository)
-        logger.info(`Repository: ${repository}`);
-    await assertIsSyncedWithRemoteAsync(repository);
+async function determineTargetVersion(currentVersion, preid, skipPrompts, preferredVersion) {
+    let targetVersion = preferredVersion;
+    const releaseTypes = getReleaseTypes(preid);
+    if (!targetVersion) {
+        if (skipPrompts) {
+            logger.info('Skipping prompts. Default to "patch" release.');
+            targetVersion = inc(currentVersion, 'patch', undefined, preid) ?? '';
+            if (!targetVersion)
+                throw new Error(`Failed to compute target version from ${currentVersion}`);
+            if (!valid(targetVersion))
+                throw new Error(`Invalid target version: ${targetVersion}`);
+            return targetVersion;
+        }
+        const choices = releaseTypes
+            .map((releaseType) => {
+            const version = inc(currentVersion, releaseType, undefined, preid);
+            return {
+                title: `${releaseType} (${version})`,
+                value: version,
+            };
+        })
+            .filter(choice => choice.value !== null)
+            .concat({
+            title: 'custom',
+            value: 'custom',
+        });
+        const { release } = await prompts({
+            type: 'select',
+            name: 'release',
+            message: 'Select release type',
+            choices,
+        });
+        if (release === 'custom') {
+            const { version } = await prompts({
+                type: 'text',
+                name: 'version',
+                message: 'Type custom version',
+                initial: currentVersion,
+            });
+            targetVersion = version;
+        }
+        else {
+            targetVersion = release;
+        }
+    }
+    // Если вместо номера версии передан тип релиза — инкрементируем
+    //
+    if (releaseTypes.includes(targetVersion))
+        targetVersion = inc(currentVersion, targetVersion, undefined, preid) ?? '';
+    if (!targetVersion)
+        throw new Error(`Failed to compute target version from ${currentVersion}`);
+    if (!valid(targetVersion))
+        throw new Error(`Invalid target version: ${targetVersion}`);
+    return targetVersion;
 }
-else {
-    logger.info('Repository: not in git work tree');
+
+const { yellow: yellow$2 } = chalk;
+async function runGitChecksAsync(context) {
+    if (!context.inWorkTree || context.skipGit)
+        return {};
+    const repoDetails = await getRepositoryDetails();
+    const { name: repository, connectionType } = repoDetails;
+    logger.log(`Repository: ${yellow$2(repository)}`);
+    await assertIsSyncedWithRemoteAsync(repository);
+    logger.step('Ensuring CI status for HEAD...');
+    await assertWorkflowResultAsync(repository, 'build');
+    return { repository, connectionType };
 }
-// Если версия не указана, предоставить возможность выбора.
-if (!targetVersion) {
-    const choices = releaseTypes
-        .map((item) => {
-        const version = getIncremented(item);
-        return { title: `${item} (${version})`, value: version };
-    })
-        .concat([{ title: 'custom', value: 'custom' }]);
-    const { release } = await prompts({
-        type: 'select',
-        name: 'release',
-        message: 'Select release type',
-        choices,
-    });
-    if (release === 'custom') {
-        const { version } = await prompts({
-            type: 'text',
-            name: 'version',
-            message: 'Type custom version',
-            initial: currentVersion,
-        });
-        // Номер версии вводится вручную.
-        targetVersion = version;
+
+const { yellow: yellow$1 } = chalk;
+async function executeReleaseAsync(context, config) {
+    const runAsync = runCommandAsync.dry(context.isDryRun);
+    let isCommitted = false;
+    try {
+        await updateVersion(context.targetVersion, config);
+        logger.info(t('release.versionUpdated', {
+            newVersion: yellow$1(`v${context.targetVersion}`),
+        }));
+        if (context.inWorkTree && !context.skipGit && hasScript('changelog')) {
+            logger.step(t('release.changelogGenerating'));
+            await runCommandAsync('pnpm', ['run', 'changelog'], { shell: true });
+            if (!context.skipPrompts) {
+                const { isContinue } = await prompts({
+                    type: 'confirm',
+                    name: 'isContinue',
+                    message: t('release.changelogConfirm'),
+                });
+                if (!isContinue) {
+                    logger.cancel(t('release.canceled'));
+                    logger.step(t('release.versionReverting'));
+                    await updateVersion(context.currentVersion, config);
+                    logger.step(t('release.versionReverted', {
+                        oldVersion: yellow$1(`v${context.currentVersion}`),
+                    }));
+                    return;
+                }
+            }
+        }
+        logger.step(t('release.lockfileUpdating'));
+        await runAsync('pnpm', ['install', '--prefer-offline'], { shell: true });
+        if (!context.inWorkTree || !context.repository) {
+            logger.note(t('release.final.noGit'));
+            return;
+        }
+        if (!context.skipGit && context.connectionType === 'ssh') {
+            const { stdout } = await runCommandAsync('git', ['diff'], { stdio: 'pipe' });
+            if (stdout) {
+                logger.step(t('release.committing'));
+                await runAsync('git', ['add', '-A']);
+                await runAsync('git', ['commit', '-m', `release: v${context.targetVersion}`]);
+                if (!context.isDryRun)
+                    isCommitted = true;
+                logger.step(t('release.pushing'));
+                const tagName = `v${context.targetVersion}`;
+                const { stdout: existingTag } = await runCommandAsync('git', ['tag', '-l', tagName], { stdio: 'pipe' });
+                if (!existingTag) {
+                    await runAsync('git', ['tag', tagName]);
+                }
+                else {
+                    logger.warn(t('release.tagAlreadyExists', {
+                        tag: yellow$1(tagName),
+                    }));
+                }
+                await runAsync('git', ['push']);
+                await runAsync('git', ['push', 'origin', `refs/tags/v${context.targetVersion}`]);
+                logger.note(yellow$1(t('release.final.gitRemote')));
+                logger.note(t('release.final.gitRemoteStatus', {
+                    workflowLink: `https://github.com/${context.repository}/actions/workflows/release.yml`,
+                }));
+            }
+            else {
+                logger.step(t('release.final.gitNoChanges'));
+            }
+        }
+        else {
+            logger.note(t('release.final.gitManual', {
+                version: yellow$1(`v${context.targetVersion}`),
+            }));
+        }
     }
-    else {
-        // Номер версии извлекается из предложенной ранее строки.
-        targetVersion = release;
+    catch (e) {
+        if (!isCommitted) {
+            logger.step(t('release.versionReverting'));
+            try {
+                await updateVersion(context.currentVersion, config);
+                logger.step(t('release.versionReverted', {
+                    oldVersion: yellow$1(`v${context.currentVersion}`),
+                }));
+            }
+            catch (rollbackError) {
+                logger.error(t('release.error.versionRevertingFailed')
+                    + '\n'
+                    + (rollbackError instanceof Error ? rollbackError.message : String(rollbackError)));
+            }
+        }
+        else {
+            logger.warn(t('release.error.versionAlreadyCommitted'));
+        }
+        throw e;
     }
 }
-// Вместо номера версии передан компонент для инкремента?
-//
-if (releaseTypes.includes(targetVersion))
-    targetVersion = getIncremented(targetVersion) ?? '';
-if (!valid(targetVersion))
-    throw new Error(`Target version is not valid: ${targetVersion}`);
-const runCommandIfNotDryAsync = runCommandAsync.ifNotDry(isDryRun);
-let isVersionUpdated = false;
-async function runAsync() {
-    if (skipPrompts) {
-        logger.info(`Releasing v${targetVersion}`);
-    }
-    else {
+
+const { yellow } = chalk;
+async function runAsync(args) {
+    // === 1. Парсинг аргументов ===
+    const { values: argv, positionals } = parseArgs(args);
+    const currentVersion = getCurrentVersion();
+    const preid = argv.preid ?? prerelease(currentVersion)?.[0];
+    const isDryRun = argv['dry-run'] ?? false;
+    const skipGit = argv['skip-git'] ?? false;
+    const skipPrompts = argv['skip-prompts'] ?? false;
+    // === 2. Проверка окружения ===
+    const inWorkTree = await checkIsInWorkTreeAsync();
+    // === 3. Git-проверки ===
+    const gitContext = await runGitChecksAsync({ inWorkTree, skipGit });
+    // === 4. Определение версии ===
+    const targetVersion = await determineTargetVersion(currentVersion, preid, skipPrompts, positionals[1]);
+    // === 5. Формирование контекста ===
+    const context = {
+        currentVersion,
+        targetVersion,
+        preid,
+        isDryRun,
+        skipGit,
+        skipPrompts,
+        inWorkTree,
+        ...gitContext,
+    };
+    // === 6. Подтверждение (если нужно) ===
+    if (!skipPrompts) {
         const { confirmRelease } = await prompts({
             type: 'confirm',
             name: 'confirmRelease',
-            message: `Releasing v${targetVersion}. Continue?`,
+            message: `Releasing ${yellow(`v${targetVersion}`)} → Continue?`,
         });
         if (!confirmRelease) {
-            logger.cancel('No changes was made.');
+            logger.cancel('Release canceled. No changes made');
             return;
         }
     }
-    if (inWorkTree) {
-        logger.log('Ensuring CI status for HEAD...');
-        await assertWorkflowResultAsync(repository, 'build');
-    }
-    updateVersion(targetVersion);
-    isVersionUpdated = true;
-    if (inWorkTree && hasScript('changelog')) {
-        logger.log('Generating changelog...');
-        await runCommandAsync('pnpm', ['run', 'changelog']);
-        if (!skipPrompts) {
-            const { isContinue } = await prompts({
-                type: 'confirm',
-                name: 'isContinue',
-                message: 'Changelog generated. Does it look good?',
-            });
-            if (!isContinue)
-                return;
-        }
-    }
-    logger.log('Updating lock-file...');
-    await runCommandAsync('pnpm', ['install', '--prefer-offline']);
-    if (!skipGit && connectionType === 'ssh') {
-        const { stdout } = await runCommandAsync('git', ['diff'], { stdio: 'pipe' });
-        if (stdout) {
-            logger.step('Committing version changes...');
-            await runCommandIfNotDryAsync('git', ['add', '-A']);
-            await runCommandIfNotDryAsync('git', ['commit', '-m', `release: v${targetVersion}`]);
-            logger.step('Pushing to GitHub');
-            await runCommandIfNotDryAsync('git', ['tag', `v${targetVersion}`]);
-            await runCommandIfNotDryAsync('git', ['push', 'origin', `refs/tags/v${targetVersion}`]);
-            await runCommandIfNotDryAsync('git', ['push']);
-            logger.note(yellow('Release will be done via GitHub Actions.')
-                + `\nCheck status at https://github.com/${repository}/actions/workflows/release.yml`);
-        }
-        else {
-            logger.info('No changes to commit.');
-        }
+    else {
+        logger.log(`Releasing ${yellow(`v${targetVersion}`)}`);
     }
+    // === 7. Загружаем конфиг ===
+    const { config: mirtaConfig } = await resolveConfigAsync(process.cwd(), argv.config);
+    // === 8. Выполнение релиза ===
+    await executeReleaseAsync(context, mirtaConfig);
 }
-await runAsync().catch((e) => {
-    if (isVersionUpdated) {
-        // Revert version changes on failed release
-        updateVersion(currentVersion);
-    }
-    throw e;
-});
+
+export { runAsync };