@mirta/cli 0.3.5 → 0.4.0

package/dist/index.mjs

@@ -1,23 +1,761 @@
-import { g as getLocalized, S as ShellError, u as useLogger } from './shell.mjs';
-import { G as GitError, a as GithubError, W as WorkflowStatusError, P as PromptCanceledError } from './github.mjs';
-import 'node:child_process';
-import 'node:url';
-import 'node:fs';
-import 'node:path';
-import 'lodash.merge';
-import 'chalk';
-import 'prompts';
-
-const messages = await getLocalized();
-const logger = useLogger(messages);
+import p from 'prompts';
+import { createStagedArgs } from '@mirta/staged-args';
+import { spawn } from 'node:child_process';
+import chalk from 'chalk';
+import { initLocalizationAsync } from '@mirta/i18n';
+import { resolve } from 'node:path';
+import cliPackage from '../package.json' with { type: 'json' };
+import { suggestClosest } from '@mirta/basics/fuzzy';
+
+class PromptCanceledError extends Error {
+    constructor() {
+        super();
+        // Убедимся, что экземпляр имеет правильный прототип
+        Object.setPrototypeOf(this, PromptCanceledError.prototype);
+        this.name = 'PromptCanceledError';
+        Error.captureStackTrace(this, PromptCanceledError);
+    }
+}
+/**
+ * @param {import('prompts').PromptObject<string> | Array<import('prompts').PromptObject<string>>} questions
+ * @param {import('prompts').Options} options
+ */
+async function prompts(questions, options) {
+    const po = {
+        onCancel: () => {
+            throw new PromptCanceledError();
+        },
+    };
+    return await p(questions, po);
+}
+
+const { t, getLocale, setLocaleAsync } = await initLocalizationAsync({
+    cwd: resolve(import.meta.dirname, '../'),
+});
+
+/**
+ * Символ-разделитель, используемый в префиксе логов.
+ *
+ * @since 0.3.0
+ *
+ **/
+const dot = '•';
+/**
+ * Баннер, отображаемый в начале логов по умолчанию.
+ *
+ * @since 0.3.0
+ *
+ **/
+const banner = `Mirta ${dot}`;
+/**
+ * Цвета текста для каждого уровня логирования.
+ *
+ * @since 0.4.0
+ *
+ **/
+const colors = {
+    debug: chalk.magenta,
+    info: chalk.cyan,
+    warn: chalk.yellow,
+    error: chalk.red,
+    success: chalk.green,
+    cancel: chalk.red,
+    step: chalk.dim,
+    note: chalk.yellowBright,
+};
+/**
+ * Цвета фона для "pill" (подсветки метки уровня).
+ *
+ * @since 0.4.0
+ *
+ **/
+const bgColors = {
+    debug: chalk.bgMagenta.black,
+    info: chalk.bgCyan.black,
+    warn: chalk.bgYellow.black,
+    error: chalk.bgRed.white,
+    success: chalk.bgGreen.black,
+    cancel: chalk.bgRed,
+};
+/**
+ * Приоритет уровней логирования. Определяет, какие сообщения будут отображаться
+ * при установленном уровне детализации.
+ *
+ * @since 0.4.0
+ *
+ **/
+const levelPriority = [
+    'debug',
+    'info',
+    'warn',
+    'error',
+    'success',
+    'cancel',
+    'step',
+    'note',
+];
+/**
+ * Целевой уровень логирования. Сообщения с уровнем ниже указанного — игнорируются.
+ *
+ * @since 0.4.0
+ *
+ **/
+let targetLevel = 0;
+/**
+ * Проверяет, должно ли сообщение быть залогировано, исходя из текущего уровня.
+ *
+ * @param level - Уровень логирования сообщения.
+ * @returns {boolean} `true`, если сообщение удовлетворяет текущему уровню детализации.
+ *
+ * @since 0.4.0
+ *
+ **/
+function shouldLog(level) {
+    const currentLevel = levelPriority.indexOf(level);
+    return currentLevel === -1 || currentLevel >= targetLevel;
+}
+/**
+ * Создаёт функцию для формирования "pill" — цветной метки с названием уровня.
+ *
+ * @param level - Уровень логирования.
+ * @returns Функция, возвращающая отформатированную метку.
+ *
+ * @since 0.4.0
+ *
+ **/
+function createPill(level) {
+    const bgColor = bgColors[level] ?? ((text) => text);
+    return (...text) => {
+        const filteredText = text
+            .filter(x => x !== undefined)
+            .join(' ');
+        if (filteredText.length === 0)
+            return '';
+        return bgColor(` ${filteredText} `) + ` ${dot} `;
+    };
+}
+/**
+ * Определяет, нужно ли применять цвет к строке сообщения.
+ *
+ * @param colorScope - Режим применения цвета.
+ * @param lineIndex - Индекс строки (для многострочных сообщений).
+ * @returns `true`, если цвет следует применить.
+ *
+ * @since 0.4.0
+ *
+ **/
+function shouldColorLine(colorScope, lineIndex) {
+    if (colorScope === 'all')
+        return true;
+    if (colorScope === 'first-line')
+        return lineIndex === 0;
+    return false;
+}
+/**
+ * Форматирует сообщение с учётом уровня, опций и цветов.
+ *
+ * @param level - Уровень логирования.
+ * @param message - Сообщение для логирования. Может быть любого типа.
+ * @param labelOrOptions - Метка (строка) или опции форматирования.
+ * @param options - Опции форматирования (если первый параметр — метка).
+ * @returns Отформатированная строка для вывода в консоль.
+ *
+ * @since 0.4.0
+ *
+ **/
+function formatMessage(level, message, labelOrOptions, options) {
+    let label;
+    let finalOptions;
+    if (typeof labelOrOptions === 'string') {
+        label = labelOrOptions;
+        finalOptions = {};
+    }
+    else {
+        finalOptions = labelOrOptions ?? {};
+    }
+    const { indent = 0, includePrefix = true, colorScope = 'first-line', colorOverride, } = finalOptions;
+    const actualLevel = colorOverride ?? level;
+    const color = colors[actualLevel];
+    const pill = createPill(actualLevel);
+    let text = '';
+    if (Array.isArray(message)) {
+        text = message.map(x => String(x)).join(' ');
+    }
+    else {
+        text = String(message);
+    }
+    const lineIndent = ' '.repeat(indent);
+    const lines = text.split('\n');
+    let prefix = includePrefix ? `${banner} ${pill(label)}` : '';
+    if (prefix && colorScope !== 'none')
+        prefix = color(prefix);
+    return lines
+        .map((line, lineIndex) => {
+        line = line.trim();
+        if (shouldColorLine(colorScope, lineIndex))
+            line = color(line);
+        return lineIndex === 0
+            ? lineIndent + prefix + line
+            : lineIndent + `${' '.repeat(2)}${line}`;
+    })
+        .join('\n');
+}
+/**
+ * Основная функция логирования. Проверяет уровень и выводит сообщение.
+ *
+ * @param level - Уровень логирования.
+ * @param value - Сообщение.
+ * @param labelOrOptions - Метка или опции.
+ * @param options - Опции (если метка передана отдельно).
+ *
+ * @since 0.4.0
+ *
+ **/
+function log(level, value, labelOrOptions, options) {
+    if (!shouldLog(level))
+        return;
+    console.log(formatMessage(level, value, labelOrOptions));
+}
+/**
+ * Публичный интерфейс логгера. Предоставляет методы для логирования на разных уровнях.
+ *
+ * @example
+ * ```ts
+ * logger.info('Команда запущена')
+ * logger.warn('Устаревший режим', 'DEPRECATED')
+ * logger.step('Сборка...', { indent: 2 })
+ * ```
+ *
+ * @since 0.4.0
+ *
+ **/
+const logger = {
+    /**
+     * Устанавливает минимальный уровень логирования.
+     *
+     * @param level - Уровень, начиная с которого выводятся сообщения.
+     *
+     **/
+    setLevel: (level) => {
+        targetLevel = levelPriority.indexOf(level);
+    },
+    /**
+     * Логирует нейтральное сообщение с визуальным оформлением успеха.
+     * Использует уровень `info`, но цвет `success` (только в префиксе).
+     *
+     **/
+    log: (value) => {
+        log('info', value, {
+            colorScope: 'prefix',
+            colorOverride: 'success',
+        });
+    },
+    /**
+     * Логирует отладочное сообщение.
+     *
+     * @param value - Сообщение.
+     * @param label - Настраиваемая метка.
+     *
+     **/
+    debug: (value, label = t('label.debug')) => {
+        log('debug', value, label);
+    },
+    /**
+     * Логирует информационное сообщение.
+     *
+     * @param value - Сообщение.
+     * @param label - Настраиваемая метка.
+     *
+     **/
+    info: (value, label = t('label.info')) => {
+        log('info', value, label);
+    },
+    /**
+     * Логирует предупреждение.
+     *
+     * @param value - Сообщение.
+     * @param label - Настраиваемая метка.
+     *
+     **/
+    warn: (value, label = t('label.warning')) => {
+        log('warn', value, label);
+    },
+    /**
+     * Логирует ошибку.
+     *
+     * @param value - Сообщение.
+     * @param label - Настраиваемая метка.
+     *
+     **/
+    error: (value, label = t('label.error')) => {
+        log('error', value, label);
+    },
+    /**
+     * Логирует сообщение об успешном завершении.
+     *
+     * @param value - Сообщение.
+     * @param label - Настраиваемая метка.
+     *
+     **/
+    success: (value, label = t('label.success')) => {
+        log('success', value, label);
+    },
+    /**
+     * Логирует сообщение об отмене действия.
+     *
+     * @param value - Сообщение.
+     * @param label - Настраиваемая метка.
+     *
+     **/
+    cancel: (value, label = t('label.canceled')) => {
+        log('cancel', value, label);
+    },
+    /**
+     * Логирует шаг процесса. Без префикса, цветной текст, с отступом.
+     *
+     * @param value - Сообщение.
+     * @param options - Настройка отступа.
+     *
+     **/
+    step: (value, options = { indent: 0 }) => {
+        log('step', value, {
+            includePrefix: false,
+            colorScope: 'all',
+            indent: options.indent,
+        });
+    },
+    /**
+     * Логирует вспомогательную заметку. Цвет применяется только к префиксу.
+     *
+     * @param value - Сообщение.
+     * @param options - Опции форматирования.
+     *
+     **/
+    note: (value, options = { indent: 0, includePrefix: true }) => {
+        log('note', value, {
+            includePrefix: options.includePrefix,
+            colorScope: 'prefix',
+            indent: options.indent,
+        });
+    },
+};
+
+/**
+ * Режим `stdio`: ввод и вывод наследуются от родительского процесса (терминал), `stderr` перехватывается.
+ *
+ * Используется, когда важно видеть прогресс команды (например, `rsync`).
+ *
+ * @since 0.4.0
+ *
+ **/
+const STDIO_INTERACTIVE = ['inherit', 'inherit', 'pipe'];
+/**
+ * Режим `stdio`: ввод игнорируется, `stdout` и `stderr` перехватываются.
+ *
+ * Используется для полного захвата вывода команды.
+ *
+ * @since 0.4.0
+ *
+ **/
+const STDIO_CAPTURE_OUTPUT = ['ignore', 'pipe', 'pipe'];
+/**
+ * Режим `stdio`: ввод и `stdout` игнорируются, `stderr` перехватывается.
+ * Используется для проверки ошибок без сохранения основного вывода.
+ *
+ * @since 0.4.0
+ *
+ **/
+const STDIO_CAPTURE_ERRORS = ['ignore', 'ignore', 'pipe'];
+/**
+ * Ошибка выполнения команды в shell.
+ *
+ * Возникает, когда команда завершилась с кодом, не входящим в `doneCodes` или `cancelCodes`.
+ *
+ **/
+class ShellError extends Error {
+    constructor(message) {
+        super(message);
+        // Убедимся, что экземпляр имеет правильный прототип
+        Object.setPrototypeOf(this, ShellError.prototype);
+        this.name = 'ShellError';
+        this.message = message;
+        Error.captureStackTrace(this, ShellError);
+    }
+}
+/**
+ * Ошибка, указывающая на отмену операции (например, через Ctrl+C).
+ *
+ * Соответствует коду выхода 130 (SIGINT).
+ *
+ * @since 0.4.0
+ *
+ **/
+class OperationCanceledError extends Error {
+    constructor() {
+        super();
+        // Убедимся, что экземпляр имеет правильный прототип
+        Object.setPrototypeOf(this, OperationCanceledError.prototype);
+        this.name = 'OperationCanceledError';
+        Error.captureStackTrace(this, OperationCanceledError);
+    }
+}
+/**
+ * Асинхронно выполняет команду и возвращает результат.
+ *
+ * Перехватывает `stdout` и `stderr`.
+ * Поддерживает кастомные коды успеха и отмены.
+ *
+ * @param command - Команда (например, `ls`, `rsync`).
+ * @param args - Аргументы команды.
+ * @param options - Опции запуска процесса.
+ * @returns Результат выполнения: код, вывод, ошибки.
+ * @throws {ShellError} Если команда завершилась с ошибкой.
+ * @throws {OperationCanceledError} Если операция была отменена пользователем.
+ *
+ **/
+async function execAsync(command, args = [], options = {}) {
+    return new Promise((resolve, reject) => {
+        const { doneCodes = [0], cancelCodes = [130], ...spawnOptions } = options;
+        spawnOptions.stdio ??= STDIO_CAPTURE_OUTPUT;
+        spawnOptions.shell ??= false;
+        const runner = spawn(command, args, spawnOptions);
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        runner.stdout?.on('data', (chunk) => {
+            stdoutChunks.push(chunk);
+        });
+        runner.stderr?.on('data', (chunk) => {
+            stderrChunks.push(chunk);
+        });
+        runner.on('error', reject);
+        runner.on('exit', (code) => {
+            const isDone = code !== null && doneCodes.includes(code);
+            const stdout = Buffer.concat(stdoutChunks).toString().trim();
+            const stderr = Buffer.concat(stderrChunks).toString().trim();
+            if (isDone) {
+                resolve({ isDone, code, stdout, stderr });
+            }
+            else {
+                const isCanceled = code !== null && cancelCodes.includes(code);
+                reject(isCanceled
+                    ? new OperationCanceledError()
+                    : new ShellError(`Failed to execute command ${command} ${args.join(' ')}: ${stderr}`));
+            }
+        });
+    });
+}
+/**
+ * Универсальная функция для запуска команд.
+ *
+ * Расширяется методами:
+ * - `.inUnixShell()` — для выполнения в WSL2
+ * - `.dry()` — для режима симуляции
+ *
+ **/
+const runCommandAsync = async (command, args, options = {}) => await execAsync(command, args, { ...options });
+runCommandAsync.inUnixShell = (wsl) => (command, args = [], options = {}) => {
+    let cmd;
+    let fullArgs = [];
+    if (process.platform === 'win32') {
+        cmd = 'wsl';
+        if (wsl)
+            fullArgs.push('-d', wsl);
+        if (options.env) {
+            for (const [key, value] of Object.entries(options.env)) {
+                fullArgs.push(`${key}=${value}`);
+            }
+        }
+        fullArgs.push(command, ...args);
+    }
+    else {
+        cmd = command;
+        fullArgs = args;
+    }
+    return execAsync(cmd, fullArgs, { ...options });
+};
+runCommandAsync.dry = (isDryRun) => {
+    if (isDryRun === false)
+        return runCommandAsync;
+    return (command, args = []) => {
+        logger.info(`${command} ${args.join(' ')}`.trimEnd() + ' (DRY RUN)');
+        return Promise.resolve({
+            isDone: true,
+            code: 0,
+            stdout: '',
+            stderr: '',
+        });
+    };
+};
+
+const baseUrl = 'https://api.github.com/repos';
+/** Класс ошибки уровня Git. */
+class GitError extends Error {
+    constructor(message) {
+        super(message);
+        // Убедимся, что экземпляр имеет правильный прототип
+        Object.setPrototypeOf(this, GitError.prototype);
+        this.name = 'GitError';
+        this.message = message;
+        Error.captureStackTrace(this, GitError);
+    }
+}
+/** Класс ошибки уровня взаимодействия GitHub. */
+class GithubError extends Error {
+    constructor(message) {
+        super(message);
+        // Убедимся, что экземпляр имеет правильный прототип
+        Object.setPrototypeOf(this, GithubError.prototype);
+        this.name = 'GithubError';
+        this.message = message;
+        Error.captureStackTrace(this, GithubError);
+    }
+}
+/** Класс ошибки уровня GitHub Workflow. */
+class WorkflowStatusError extends Error {
+    constructor(message) {
+        super(message);
+        // Убедимся, что экземпляр имеет правильный прототип
+        Object.setPrototypeOf(this, WorkflowStatusError.prototype);
+        this.name = 'WorkflowStatusError';
+        this.message = message;
+        Error.captureStackTrace(this, WorkflowStatusError);
+    }
+}
+/** Определяет, находится ли текущее решение в рабочем дереве Git. */
+async function checkIsInWorkTreeAsync() {
+    try {
+        const { stdout } = await runCommandAsync('git', ['rev-parse', '--is-inside-work-tree'], { stdio: 'pipe' });
+        return stdout === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+const getConnectionType = (url) => {
+    if (url.startsWith('git@'))
+        return 'ssh';
+    if (url.startsWith('https://'))
+        return 'https';
+};
+/** Возвращает имя репозитория и тип подключения. */
+async function getRepositoryDetails() {
+    const { stdout, stderr } = await runCommandAsync('git', ['config', 'remote.origin.url'], { stdio: 'pipe' });
+    if (stderr)
+        throw new GitError(stderr);
+    // Match the URLs like:
+    // git@github.com:wb-mirta/core.git
+    // https://github.com/wb-mirta/core.git
+    //
+    const regex = /^(?:git@|https:\/\/)(?:[^/:]+)[/:]?(.*?).git$/i;
+    const match = regex
+        .exec(stdout);
+    if (!match?.[1])
+        throw new GitError(`Unable to detect remote origin url`);
+    return {
+        name: match[1],
+        connectionType: getConnectionType(stdout),
+    };
+}
+/** Возвращает SHA текущего HEAD. */
+async function getShaAsync() {
+    return (await runCommandAsync('git', ['rev-parse', 'HEAD'])).stdout;
+}
+/** Возвращает имя текущей ветки. */
+async function getBranchAsync() {
+    return (await runCommandAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'])).stdout;
+}
+/** Проверяет, синхронизирован ли текущий HEAD с удаленным. */
+async function assertIsSyncedWithRemoteAsync(repository) {
+    let isSynced = false;
+    try {
+        const branch = await getBranchAsync();
+        const remote = await fetch(`${baseUrl}/${repository}/commits/${branch}?per_page=1`);
+        const data = await remote.json();
+        isSynced = data.sha === await getShaAsync();
+    }
+    catch {
+        throw new GithubError('Failed to check whether local HEAD is up-to-date with remote');
+    }
+    if (!isSynced)
+        throw new GithubError('Local HEAD is not up-to-date with remote');
+}
+/** Проверяет успешность CI-построения последнего коммита. */
+async function assertWorkflowResultAsync(repository, name) {
+    let isBuildPassed = false;
+    try {
+        const sha = await getShaAsync();
+        const result = await fetch(`${baseUrl}/${repository}/actions/runs?head_sha=${sha}&status=completed&exclude_pull_requests=true`);
+        const data = await result.json();
+        isBuildPassed = data.workflow_runs.some(({ name: workflowName, conclusion }) => workflowName.toLowerCase() === name.toLowerCase()
+            && conclusion === 'success');
+    }
+    catch {
+        throw new GithubError('Unable to get CI status for the current commit');
+    }
+    if (!isBuildPassed)
+        throw new WorkflowStatusError('CI build of the latest commit has not passed yet');
+}
+
+const { dim, yellow } = chalk;
+const helpMessageEn = `\
+Performs operations over monorepo projects powered by the Mirta Framework.
+
+${yellow('Usage:')}
+  mirta [command] [options...]
+
+${yellow('Global flags:')}
+  --help, -h
+    ${dim('Displays help information about available commands and options.')}
+  --version, -v
+    ${dim('Prints the version of this CLI utility.')}
+
+${yellow('Commands:')}
+  release
+  ${dim('Increase package versions following semantic versioning rules.')}
+  publish
+  ${dim('Builds and publishes packages to npm registry.')}
+
+${yellow(`Options for 'release':`)}
+  --dry-run, --dry
+    ${dim('Runs the command in simulation mode. Shows what would change but does not apply modifications.')}
+  --preid <id>
+    ${dim('Sets a custom pre-release identifier (e.g., `alpha`, `beta.1`, `rc`).')}
+  --skip-prompts
+    ${dim('Skips interactive prompts, using default values.')}
+  --skip-git
+    ${dim('Disables creating a commit and tag. Git changes remain uncommitted.')}
+
+${yellow(`Options for 'publish':`)}
+  --dry-run, --dry
+    ${dim('Runs in simulation mode. Shows what would happen, but does not publish')}
+  --skip-build
+  ${dim('Skips running `pnpm run build` before publishing.')}
+  --skip-git
+    ${dim('Disables git state checks (equivalent to `--no-git-checks` in `pnpm publish`).')}
+`;
+const helpMessageRu = `\
+Выполняет операции над проектами монорепозитория, работающими на базе фреймворка Mirta.
+
+${yellow('Использование:')}
+  mirta [command] [options...]
+
+${yellow('Команды:')}
+  release
+  ${dim('Повышение версий пакетов согласно правилам семантического версионирования.')}
+  publish
+  ${dim('Сборка и публикация пакетов в реестр npm.')}
+
+${yellow('Общие флаги:')}
+  --help, -h
+    ${dim('Отображает справку по доступным командам и параметрам.')}
+  --version, -v
+    ${dim('Выводит версию данной утилиты.')}
+
+${yellow(`Опции для 'release':`)}
+  --dry-run, --dry
+    ${dim('Запускает команду в режиме симуляции. Показывает изменения, но не применяет их.')}
+  --preid <id>
+    ${dim('Задаёт кастомный префикс для преверсии (например, `alpha`, `beta.1`, `rc`).')}
+  --skip-prompts
+    ${dim('Пропускает интерактивные запросы. Используются значения по умолчанию.')}
+  --skip-git
+    ${dim('Не создаёт коммит и тег. Git-изменения остаются в рабочей директории.')}
+
+${yellow(`Опции для 'publish':`)}
+  --dry-run, --dry
+    ${dim('Запускает команду в режиме симуляции. Показывает изменения, но не применяет их.')}
+  --skip-build
+    ${dim('Пропускает выполнение `pnpm run build` перед публикацией')}
+  --skip-git
+    ${dim('Отключает проверки git-состояния (аналог `--no-git-checks` в `pnpm publish`)')}
+`;
+const getHelpMessage = () => getLocale() === 'ru-RU'
+    ? helpMessageRu
+    : helpMessageEn;
+
+const runners = {
+    release: async () => (await import('./release.mjs')).runAsync,
+    publish: async () => (await import('./publish.mjs')).runAsync,
+    deploy: async () => (await import('./deploy.mjs')).runAsync,
+};
+async function resolveRunnerAsync(nameInput) {
+    if (!(nameInput in runners)) {
+        const knownNames = Object.keys(runners);
+        const suggestion = nameInput.length > 1
+            ? suggestClosest(nameInput, knownNames, { maxDistance: 2 })
+            : undefined;
+        const errorInput = suggestion
+            ? t('command.suggest', { input: nameInput, suggestion })
+            : nameInput;
+        throw new Error(t('command.notFound', { input: errorInput }));
+    }
+    const runner = runners[nameInput];
+    return {
+        runAsync: await runner(),
+    };
+}
+
+function assertNoParseErrors(result) {
+    if (!result.hasErrors)
+        return;
+    const lines = [
+        t('args.errorHeader', { count: result.errors.length }),
+    ];
+    for (const error of result.errors) {
+        switch (error.type) {
+            case 'unknown-option':
+                if (error.suggestion) {
+                    lines.push(t('args.unknownOptionSuggest', {
+                        option: chalk.bold(error.option),
+                        suggestion: chalk.bold(`--${error.suggestion}`),
+                    }));
+                }
+                else {
+                    lines.push(t('args.unknownOption', {
+                        option: chalk.bold(error.option),
+                    }));
+                }
+                break;
+            case 'missing-value':
+                lines.push(t('args.missingValue', {
+                    option: chalk.bold(error.option),
+                }));
+                break;
+        }
+    }
+    throw new Error(lines.join('\n'));
+}
+
+const commonOptions = {
+    locale: {
+        type: 'string',
+    },
+    version: {
+        type: 'boolean',
+        short: 'v',
+    },
+    help: {
+        type: 'boolean',
+        short: 'h',
+    },
+};
 async function run() {
-    const command = process.argv[2];
-    if (command === 'release') {
-        await import('./release.mjs');
+    const args = createStagedArgs(process.argv.slice(2));
+    const parseResult = args.parse(commonOptions);
+    assertNoParseErrors(parseResult);
+    const { values: argv, positionals, stagedArgs: runnerArgs } = parseResult.data;
+    if (argv.locale)
+        await setLocaleAsync(argv.locale);
+    if (argv.version) {
+        console.log(`${cliPackage.name} v${cliPackage.version}`);
+        return;
     }
-    else if (command === 'publish') {
-        await import('./publish.mjs');
+    if (argv.help || !positionals.length) {
+        console.log(getHelpMessage());
+        return;
     }
+    const module = await resolveRunnerAsync(positionals[0]);
+    await module.runAsync(runnerArgs);
 }
 function prettify(message, name) {
     if (name && message.startsWith(name))
@@ -28,11 +766,10 @@ run().catch((e) => {
     if (e instanceof GitError || e instanceof GithubError || e instanceof WorkflowStatusError || e instanceof ShellError) {
         logger.error(prettify(e.message, e.name));
     }
-    else if (e instanceof PromptCanceledError) {
-        logger.cancel(messages.errors.operationCanceled);
+    else if (e instanceof PromptCanceledError || e instanceof OperationCanceledError) {
+        logger.cancel(t('step.canceled'));
     }
     else if (e instanceof Error && 'code' in e) {
-        // if (e.code === 'ERR_PARSE_ARGS_UNKNOWN_OPTION')
         // if (e.code === 'ENOENT')
         logger.error(prettify(e.message, e.name));
     }
@@ -44,3 +781,5 @@ run().catch((e) => {
     }
     process.exit(1);
 });
+
+export { STDIO_INTERACTIVE as S, assertNoParseErrors as a, assertIsSyncedWithRemoteAsync as b, assertWorkflowResultAsync as c, checkIsInWorkTreeAsync as d, STDIO_CAPTURE_ERRORS as e, getRepositoryDetails as g, logger as l, prompts as p, runCommandAsync as r, t };