create-mirta 0.3.4 → 0.4.3

package/dist/index.mjs

@@ -1,191 +1,569 @@
-import { fileURLToPath } from 'node:url';
-import path, { resolve, dirname, basename } from 'node:path';
-import { parseArgs } from 'node:util';
-import fs, { existsSync, readdirSync, lstatSync, unlinkSync, rmdirSync, promises, readFileSync, writeFileSync } from 'node:fs';
-import * as p from '@clack/prompts';
-import { intro, text, confirm, multiselect, select, outro } from '@clack/prompts';
+import cliPackage from '../package.json' with { type: 'json' };
+import { createStagedArgs } from '@mirta/staged-args';
+import { initLocalizationAsync } from '@mirta/i18n';
+import { resolve, basename, dirname, sep } from 'node:path';
 import chalk from 'chalk';
-import isUnicodeSupported from 'is-unicode-supported';
-import merge from 'lodash.merge';
+import { readFileSync } from 'node:fs';
 import { fruit } from 'gradient-string';
-import cliPackage from '../package.json' with { type: 'json' };
-import ejs from 'ejs';
-import { spawn } from 'node:child_process';
+import p from 'prompts';
+import { isString } from '@mirta/basics';
+import fs from 'node:fs/promises';
 
-function canSkipDir(targetDir) {
-    if (!existsSync(targetDir))
-        return true;
-    const files = readdirSync(targetDir);
-    if (files.length === 0)
-        return true;
-    if (files.length === 1 && files[0] === '.git')
-        return true;
-    return false;
-}
-function postOrderDirectoryTraverse(dir, dirCallback, fileCallback) {
-    for (const filename of readdirSync(dir)) {
-        if (filename === '.git') {
-            continue;
-        }
-        const fullpath = resolve(dir, filename);
-        if (lstatSync(fullpath).isDirectory()) {
-            postOrderDirectoryTraverse(fullpath, dirCallback, fileCallback);
-            dirCallback(fullpath);
-            continue;
+const { t, getLocale, setLocaleAsync } = await initLocalizationAsync({
+    cwd: resolve(import.meta.dirname, '../'),
+});
+
+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;
         }
-        fileCallback(fullpath);
     }
-}
-function emptyDir(targetDir) {
-    if (!existsSync(targetDir))
-        return;
-    postOrderDirectoryTraverse(targetDir, (path) => {
-        rmdirSync(path);
-    }, (path) => {
-        unlinkSync(path);
-    });
+    throw new Error(lines.join('\n'));
 }
 
-const fallbackLocale = 'en-US';
-const localesPath = './locales';
-let currentLocale = '';
 /**
+ * Символ-разделитель, используемый в префиксе логов.
  *
- * Used to link obtained locale with correct locale file.
+ * @since 0.3.0
  *
- * @param locale Obtained locale
- * @returns locale that linked with correct name
- */
-function linkLocale(locale) {
-    if (locale === 'C')
-        return fallbackLocale;
-    let linkedLocale;
-    try {
-        linkedLocale = Intl.getCanonicalLocales(locale)[0];
+ **/
+const dot = '•';
+/**
+ * Баннер, отображаемый в начале логов по умолчанию.
+ *
+ * @since 0.3.0
+ *
+ **/
+const banner$1 = `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 = {};
     }
-    catch (error) {
-        console.warn(`${JSON.stringify(error)}, invalid language tag: "${locale}"`);
+    else {
+        finalOptions = labelOrOptions ?? {};
     }
-    switch (linkedLocale) {
-        default:
-            linkedLocale = locale;
+    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(' ');
     }
-    return linkedLocale;
-}
-function getLocale() {
-    if (currentLocale)
-        return currentLocale;
-    const shellLocale = process.env.LC_ALL
-        ?? process.env.LC_MESSAGES
-        ?? process.env.LANG
-        ?? Intl.DateTimeFormat().resolvedOptions().locale;
-    return currentLocale = linkLocale(shellLocale.split('.')[0].replace('_', '-'));
-}
-async function loadLanguageFile(filePath) {
-    return await promises.readFile(filePath, 'utf-8').then((content) => {
-        const data = JSON.parse(content);
-        return data;
-    });
+    else {
+        text = String(message);
+    }
+    const lineIndent = ' '.repeat(indent);
+    const lines = text.split('\n');
+    let prefix = includePrefix ? `${banner$1} ${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');
 }
-async function loadLocale(localesRoot) {
-    currentLocale = getLocale();
-    const fallbackFilePath = resolve(localesRoot, `${fallbackLocale}.json`);
-    const targetFilePath = resolve(localesRoot, `${currentLocale}.json`);
-    const messages = await loadLanguageFile(fallbackFilePath);
-    if (!messages)
-        throw Error('Fallback locale file not found.');
-    if (existsSync(targetFilePath))
-        merge(messages, await loadLanguageFile(targetFilePath));
-    return messages;
+/**
+ * Основная функция логирования. Проверяет уровень и выводит сообщение.
+ *
+ * @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));
 }
-let localized;
-async function getLocalized() {
-    const path = fileURLToPath(new URL(localesPath, import.meta.url));
-    return localized ??= await loadLocale(path);
+/**
+ * Публичный интерфейс логгера. Предоставляет методы для логирования на разных уровнях.
+ *
+ * @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,
+        });
+    },
+};
+
+/**
+ * Имя текущего пакета в формате, используемом в npm-реестре.
+ *
+ * @since 0.4.0
+ *
+ * @internal
+ *
+ **/
+const THIS_PACKAGE_NAME = 'create-mirta';
+/**
+ * Источник фичи - CLI.
+ *
+ * @since 0.4.0
+ *
+ **/
+const FEATURE_ORIGIN_CLI = 'cli';
+
+/**
+ * Специализированный класс для обработки ошибок, связанных с работой локализации.
+ *
+ * Предоставляет структурированные и типизированные ошибки с использованием кодов, что упрощает
+ * программную обработку исключений в инструментах, работающих с пакетами.
+ *
+ * @example
+ * ```ts
+ * throw CreationError.get('template.notFound', 'fullstack')
+ * ```
+ * @since 0.4.0
+ *
+ **/
+class CreationError extends Error {
+    /**
+     * Код ошибки для программной идентификации.
+     *
+     * Позволяет точно определить причину ошибки в обработчиках `try/catch`.
+     *
+     **/
+    code;
+    /**
+     * Приватный конструктор, используемый только внутри
+     * класса для создания экземпляров ошибки.
+     *
+     * @param message - Полное сообщение об ошибке.
+     * @param code - Код ошибки для идентификации.
+     * @param scope - Пространство имён или модуль, в котором возникла ошибка.
+     *                По умолчанию — {@link THIS_PACKAGE_NAME}.
+     *
+     **/
+    constructor(message, code) {
+        super(`[${THIS_PACKAGE_NAME}] ${message}`);
+        this.name = 'CreationError';
+        this.code = code;
+        // Захватываем стек вызовов, исключая фабричный метод `get`,
+        // чтобы улучшить читаемость трассировки.
+        //
+        if ('captureStackTrace' in Error)
+            // eslint-disable-next-line @typescript-eslint/unbound-method
+            Error.captureStackTrace(this, CreationError.get);
+    }
+    /** Карта кодов ошибок с соответствующими сообщениями. */
+    static codeMappings = {
+        'load.noTemplates': (templateType) => t('load.noTemplates', { type: templateType }),
+        'template.notFound': (templateName) => t('template.notFound', { name: templateName }),
+        'template.invalidConfig': (templateName) => `Invalid template config of ${templateName}`,
+        'template.duplicateName': (templateName) => `Duplicate template name ${templateName}`,
+        'project.outsideRoot': () => t('project.outsideRoot'),
+        'project.denyOverwrite': () => t('project.denyOverwrite'),
+    };
+    /**
+     * Фабричный метод для создания экземпляра ошибки по её коду.
+     *
+     * Автоматически подставляет сообщение из `codeMappings` и формирует ошибку с заданными параметрами.
+     *
+     * @template T - Ограниченный ключами `codeMappings` тип, гарантирующий корректность кода.
+     * @param code - Код ошибки (например, `'alreadyDefined'`).
+     * @param args - Аргументы, соответствующие параметрам функции сообщения из `codeMappings`.
+     * @returns Новый экземпляр {@link CreationError} с шаблонным сообщением.
+     *
+     **/
+    static get(code, ...args) {
+        const messageFn = this.codeMappings[code];
+        const message = messageFn(...args);
+        return new CreationError(message, code);
+    }
 }
 
-const { red: red$1, green, bgRed, bgGreen, } = chalk;
-const dot = '•';
-const banner$1 = `Mirta ${dot}`;
-green(banner$1);
-red$1(banner$1);
-const successPill = (message) => message
-    ? bgGreen.black(` ${message} `) + ' '
-    : '';
-const errorPill = (message) => message
-    ? bgRed.white(` ${message} `) + ' '
-    : '';
-const formatSuccess = (message, title) => message ? `${successPill(title)}${green(dot, message)}` : '';
-const formatError = (message, title) => message ? `${errorPill(title)}${red$1(dot, message)}` : '';
-
-const unicode = isUnicodeSupported();
-const unicodeOr = (c, fallback) => (unicode ? c : fallback);
-const S_BAR = unicodeOr('│', '|');
-function usePrompts(messages) {
-    function cancel(message = messages.errors.operationCanceled) {
-        p.cancel(formatError(message, messages.status.canceled));
+/**
+ * Ошибка, указывающая на отмену операции (например, через Ctrl+C).
+ *
+ * Соответствует коду выхода 130 (SIGINT).
+ *
+ * @since 0.4.0
+ *
+ **/
+class OperationCanceledError extends Error {
+    constructor() {
+        super();
+        this.name = 'OperationCanceledError';
+        Error.captureStackTrace(this, OperationCanceledError);
     }
-    async function prompt(cancellablePromise) {
-        const result = await cancellablePromise;
-        if (p.isCancel(result)) {
-            cancel();
-            process.exit(1);
-        }
-        return result;
+}
+
+class PromptCanceledError extends Error {
+    constructor() {
+        super();
+        this.name = 'PromptCanceledError';
+        Error.captureStackTrace(this, PromptCanceledError);
     }
-    function inlineSub(message) {
-        return `\n${chalk.gray(S_BAR)}  ${message}`;
+}
+
+async function loadAsync(type) {
+    switch (type) {
+        case 'classic':
+            return await import('./classic.mjs');
+        case 'mono':
+            return await import('./mono.mjs');
+        default:
+            throw new Error(`Unknown project type: ${type}`);
     }
-    return {
-        cancel,
-        prompt,
-        step: p.log.step,
-        message: p.log.message,
-        inlineSub,
-    };
+}
+async function resolveRunnerAsync(projectType) {
+    return await loadAsync(projectType);
 }
 
 const canUseColors = process.stdout.isTTY
     && process.stdout.getColorDepth() > 8;
-const data = readFileSync(new URL('./assets/logo.art', import.meta.url), 'utf-8');
+const data = readFileSync(new URL('../assets/logo.art', import.meta.url), 'utf-8');
 const banner = canUseColors
     ? fruit(data)
     : data;
 
-const { dim: dim$1, yellow: yellow$1 } = chalk;
-const locale$1 = getLocale();
+const finalMessageEn = `\
+${chalk.green('Welcome to your new wb-rules project!')} 🎉
+Open it in VSCode or your favourite editor and start building.
+
+📚 Documentation:
+https://dzen.ru/wihome
+
+💡 Mirta is powered entirely by community support.
+To keep the project alive and growing, your help is essential.
+
+💖 A recurring subscription on Boosty is the best way to support:
+https://boosty.to/wihome
+
+☕ One-time tips are also appreciated:
+https://pay.cloudtips.ru/p/58512cca
+
+⭐ Your star on GitHub helps others discover Mirta:
+https://github.com/wb-mirta/core
+
+Thank you for using Mirta!
+`;
+const finalMessageRu = `\
+${chalk.green('Добро пожаловать в ваш новый проект wb-rules!')} 🎉
+Откройте его в VSCode или другом редакторе и начинайте разработку.
+
+📚 Документация:
+https://dzen.ru/wihome
+
+Мирта развивается только за счёт добровольных взносов.
+Чтобы проект жил и рос — нужна ваша поддержка.
+
+💖 Регулярная подписка на Boosty — лучший способ помочь:
+https://boosty.to/wihome
+
+☕ Также можно поддержать разовым платежом:
+https://pay.cloudtips.ru/p/58512cca
+
+⭐ Нравится фреймворк? Поставьте ему звёздочку на GitHub:
+https://github.com/wb-mirta/core
+
+Спасибо, что выбрали Мирту!
+`;
+function getFinalMessage() {
+    const locale = getLocale();
+    return locale === 'ru-RU'
+        ? finalMessageRu
+        : finalMessageEn;
+}
+
+const { dim, yellow } = chalk;
 const helpMessageEn = `\
 Creates a new wb-rules project with the Mirta Framework
 
 Starts the CLI in interactive mode when no feature flags is provided,
 or if the directory argument is not a valid project name.
 
-${yellow$1('Usage:')}
+${yellow('Usage:')}
   create-mirta [feature_flags...] [options...] [directory]
 
-${yellow$1('Feature flags:')}
+${yellow('Feature flags:')}
   --default
-    ${dim$1('Create a project with the default configuration without any additional features')}
+    ${dim('Create a project with the default configuration without any additional features')}
   --eslint
-    ${dim$1('Add ESLint for code quality')}
+    ${dim('Add ESLint for code quality')}
   --vitest
-    ${dim$1('Add Vitest for unit testing')}
+    ${dim('Add Vitest for unit testing')}
   --store
-    ${dim$1('Add store for state management')}
+    ${dim('Add store for state management')}
 
-${yellow$1('Options:')}
+${yellow('Options:')}
   --ssh
-    ${dim$1('Set SSH destination of deployment process as [username@][hostname][:port]')}
+    ${dim('Set SSH destination of deployment process as [username@][hostname][:port]')}
   --rutoken
-    ${dim$1('Use Rutoken ECP as encrypted store of SSH private key')}
+    ${dim('Use Rutoken ECP as encrypted store of SSH private key')}
   -v, --version
-    ${dim$1('Display the version number of this CLI')}
+    ${dim('Display the version number of this CLI')}
   -f, --force
-    ${dim$1('Create the project even if the directory is not empty')}
+    ${dim('Create the project even if the directory is not empty')}
   -b, --bare
-    ${dim$1('Create a barebone project without any code')}
+    ${dim('Create a barebone project without any code')}
   -h, --help
-    ${dim$1('Display this help message')}
+    ${dim('Display this help message')}
 `;
 const helpMessageRu = `\
 Создаёт новый проект wb-rules с использованием Mirta Framework
@@ -193,612 +571,344 @@ const helpMessageRu = `\
 Запускает CLI в интерактивном режиме, если не указано флагов функционала
 или название каталога не подходит в качестве названия проекта.
 
-${yellow$1('Использование:')}
+${yellow('Использование:')}
   create-mirta [feature_flags...] [options...] [directory]
 
-${yellow$1('Флаги функционала:')}
+${yellow('Флаги функционала:')}
   --default
-    ${dim$1('Создаёт проект с конфигурацией по умолчанию, без дополнений')}
+    ${dim('Создаёт проект с конфигурацией по умолчанию, без дополнений')}
   --eslint
-    ${dim$1('Добавить ESLint для контроля качества кода')}
+    ${dim('Добавить ESLint для контроля качества кода')}
   --vitest
-    ${dim$1('Добавить Mirta Testing для юнит-тестирования')}
+    ${dim('Добавить Mirta Testing для юнит-тестирования')}
   --store
-    ${dim$1('Добавить хранилище состояний')}
+    ${dim('Добавить хранилище состояний')}
 
-${yellow$1('Опции:')}
+${yellow('Опции:')}
   --ssh
-    ${dim$1('Настроить подключение SSH для деплоя в формате [username@][hostname][:port]')}
+    ${dim('Настроить подключение SSH для деплоя в формате [username@][hostname][:port]')}
   --rutoken
-    ${dim$1('Использовать Рутокен ЭЦП в качестве хранилища для закрытого ключа SSH')}
+    ${dim('Использовать Рутокен ЭЦП в качестве хранилища для закрытого ключа SSH')}
   -v, --version
-    ${dim$1('Отобразить номер версии данного CLI')}
+    ${dim('Отобразить номер версии данного CLI')}
   -f, --force
-    ${dim$1('Создать проект, даже если целевая директория содержит файлы')}
+    ${dim('Создать проект, даже если целевая директория содержит файлы')}
   -b, --bare
-    ${dim$1('Создать проект-заготовку, без кода примеров')}
+    ${dim('Создать проект-заготовку, без кода примеров')}
   -h, --help
-    ${dim$1('Отобразить данное сообщение')}
+    ${dim('Отобразить данное сообщение')}
 `;
-const helpMessage = locale$1 === 'ru-RU'
-    ? helpMessageRu
-    : helpMessageEn;
-
-const featureFlags = ({
-    default: {
-        type: 'boolean',
-    },
-    eslint: {
-        type: 'boolean',
-    },
-    vitest: {
-        type: 'boolean',
-    },
-    store: {
-        type: 'boolean',
-    },
-});
-const allOptions = ({
-    ...featureFlags,
-    ssh: {
-        type: 'string',
-    },
-    rutoken: {
-        type: 'boolean',
-    },
-    version: {
-        type: 'boolean',
-        short: 'v',
-    },
-    force: {
-        type: 'boolean',
-        short: 'f',
-    },
-    bare: {
-        type: 'boolean',
-        short: 'b',
-    },
-    help: {
-        type: 'boolean',
-        short: 'h',
-    },
-});
-
-const urlRegex = /(?:(?<username>.+?)@)?(?:(?<hostname>[^:@\s]+))?(?::(?<port>\d+))?/;
-function parseUrl(value) {
-    if (!value)
-        return {};
-    return (urlRegex.exec(value))?.groups ?? {};
+function getHelpMessage() {
+    const locale = getLocale();
+    return locale === 'ru-RU'
+        ? helpMessageRu
+        : helpMessageEn;
 }
 
-const isObject = (val) => typeof val === 'object';
+async function prompts(questions, options = {}) {
+    const po = {
+        onCancel: () => {
+            throw new PromptCanceledError();
+        },
+        ...options,
+    };
+    return await p(questions, po);
+}
 
-function sortDependencies(packageJson) {
-    const sorted = {};
-    const depTypes = [
-        'dependencies',
-        'devDependencies',
-        'peerDependencies',
-        'optionalDependencies',
-    ];
-    depTypes.forEach((depType) => {
-        if (isObject(packageJson[depType])) {
-            const sourceDeps = packageJson[depType];
-            const sortedDeps = sorted[depType] = {};
-            Object.keys(packageJson[depType])
-                .sort()
-                .forEach((name) => {
-                sortedDeps[name] = sourceDeps[name];
-            });
+// Префиксы для определения типа
+const MONO_PREFIX = /^(mono)-/;
+async function pickProjectAsync(templateInput) {
+    if (isString(templateInput)) {
+        if (MONO_PREFIX.test(templateInput)) {
+            return {
+                type: 'mono',
+                templateName: templateInput.replace(MONO_PREFIX, ''),
+            };
         }
+        // Всё остальное — классический тип проекта,
+        // полное название шаблона.
+        //
+        return {
+            type: 'classic',
+            templateName: templateInput.replace(/^classic-/, ''),
+        };
+    }
+    const { projectType } = await prompts({
+        type: 'select',
+        name: 'projectType',
+        message: t('projectType.prompt'),
+        hint: t('hint.select'),
+        choices: [
+            {
+                title: t('projectType.classic'),
+                value: 'classic',
+            },
+            {
+                title: t('projectType.mono'),
+                value: 'mono',
+            },
+        ],
     });
-    return {
-        ...packageJson,
-        ...sorted,
-    };
+    // Шаблон будет выбран позже.
+    return { type: projectType };
 }
 
-const mergeArrayWithDedupe = (a, b) => Array.from(new Set([...a, ...b]));
-/**
- * Recursively merge the content of the new object to the existing one
- * @param {Object} target the existing object
- * @param {Object} source the new object
- */
-function deepMerge(target, source) {
-    for (const key of Object.keys(source)) {
-        const oldVal = target[key];
-        const newVal = source[key];
-        if (Array.isArray(oldVal) && Array.isArray(newVal)) {
-            target[key] = mergeArrayWithDedupe(oldVal, newVal);
+const templatesDir = resolve(import.meta.dirname, '../templates');
+function assertConfigIsValid(value) {
+    if (typeof value !== 'object' || value === null)
+        throw new Error('Template config must be an object');
+}
+async function discoverTemplatesAsync(type) {
+    const pathPattern = resolve(templatesDir, `{shared,${type}}/*/template.json`);
+    const templates = new Map();
+    for await (const filePath of fs.glob(pathPattern)) {
+        let rawConfig;
+        try {
+            rawConfig = JSON.parse(await fs.readFile(filePath, 'utf-8'));
         }
-        else if (isObject(oldVal) && isObject(newVal)) {
-            target[key] = deepMerge(oldVal, newVal);
+        catch {
+            throw CreationError.get('template.invalidConfig', basename(dirname(filePath)));
         }
-        else {
-            target[key] = newVal;
+        assertConfigIsValid(rawConfig);
+        const rootDir = dirname(filePath);
+        const name = (rawConfig.name || basename(rootDir));
+        if (templates.has(name))
+            throw CreationError.get('template.duplicateName', name);
+        templates.set(name, {
+            ...rawConfig,
+            type: type,
+            name: name,
+            rootDir: rootDir,
+            displayName: rawConfig.displayName ?? name,
+            description: rawConfig.description ?? '',
+            order: rawConfig.order ?? Number.POSITIVE_INFINITY,
+        });
+    }
+    return templates;
+}
+
+function buildSequence(target, templates) {
+    const stack = [target];
+    // Иерархическая последовательность шаблонов.
+    const sequence = [];
+    // Для предотвращения зацикливания.
+    const seen = new Set();
+    let template;
+    // Извлекаем последний шаблон из стека.
+    while ((template = stack.pop())) {
+        if (seen.has(template.name))
+            throw new Error('Cyclic template inheritance');
+        seen.add(template.name);
+        if (template.extends) {
+            const parent = templates.get(template.extends);
+            if (!parent)
+                throw new Error(`Unknown parent template ${template.extends} in ${template.name}`);
+            stack.push(parent);
         }
+        sequence.push(template);
     }
-    return target;
+    // Инвертированная последовательность начинается с корня.
+    return sequence.reverse();
 }
 
-function renderJson(source, targetFilePath, handle) {
-    const existingData = JSON.parse(fs.readFileSync(targetFilePath, 'utf-8'));
-    const newData = typeof source === 'string'
-        ? JSON.parse(fs.readFileSync(source, 'utf-8'))
-        : source;
-    let mergedData = deepMerge(existingData, newData);
-    if (handle)
-        mergedData = handle(mergedData);
-    fs.writeFileSync(targetFilePath, JSON.stringify(mergedData, null, 2) + '\n');
+async function pickTargetAsync(templates, templateName) {
+    if (templateName) {
+        const template = templates.get(templateName);
+        if (!template)
+            throw CreationError.get('template.notFound', templateName);
+        return template;
+    }
+    if (templates.size === 1)
+        return templates.values().next().value;
+    const response = await prompts({
+        type: 'select',
+        name: 'templateName',
+        message: t('template.select'),
+        hint: t('hint.select'),
+        choices: [...templates.values()]
+            .filter(x => !x.hidden)
+            .sort((a, b) => (a.order - b.order))
+            .map(x => ({
+            title: t.plain(`templates.${x.name}.name`, x.displayName),
+            description: t.plain(`templates.${x.name}.description`, x.description),
+            value: x.name,
+        })),
+    });
+    const template = templates.get(response.templateName);
+    if (!template)
+        throw CreationError.get('template.notFound', response.templateName);
+    return template;
 }
 
-function renderTemplate(sourcePath, targetPath) {
-    const stats = fs.statSync(sourcePath);
-    if (stats.isDirectory()) {
-        if (path.basename(sourcePath) === 'node_modules')
-            return;
-        fs.mkdirSync(targetPath, { recursive: true });
-        for (const file of fs.readdirSync(sourcePath)) {
-            if (file === '.gitkeep')
-                continue;
-            renderTemplate(path.resolve(sourcePath, file), path.resolve(targetPath, file));
-        }
-        return;
-    }
-    const filename = path.basename(sourcePath);
-    if (filename === 'package.json' && fs.existsSync(targetPath)) {
-        renderJson(sourcePath, targetPath, result => sortDependencies(result));
-        return;
-    }
-    if (['extensions.json', 'settings.json', 'tasks.json', 'tsconfig.json'].includes(filename) && fs.existsSync(targetPath)) {
-        renderJson(sourcePath, targetPath);
-        return;
-    }
-    if (filename.startsWith('_')) {
-        // rename `_file` to `.file`
-        targetPath = path.resolve(path.dirname(targetPath), filename.replace(/^_/, '.'));
-    }
-    if (filename === '_gitignore' && fs.existsSync(targetPath)) {
-        const existingContent = fs.readFileSync(targetPath, 'utf-8');
-        const newContent = fs.readFileSync(sourcePath, 'utf-8');
-        fs.writeFileSync(targetPath, existingContent + '\n' + newContent);
-        return;
-    }
-    fs.copyFileSync(sourcePath, targetPath);
+async function resolveTemplateSequenceAsync(selection) {
+    const { type, templateName } = selection;
+    const templates = await discoverTemplatesAsync(type);
+    if (templates.size === 0)
+        throw CreationError.get('load.noTemplates', type);
+    const target = await pickTargetAsync(templates, templateName);
+    return buildSequence(target, templates);
 }
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-function renderEjs(filePath, data) {
-    const fullPath = resolve(__dirname, filePath);
-    const template = readFileSync(fullPath, 'utf-8');
-    return ejs.render(template, data, {});
+async function confirmOverwriteAsync(projectRoot) {
+    const locationText = t('overwrite.notEmpty', { path: chalk.yellow(projectRoot) });
+    const promptText = chalk.red(t('overwrite.prompt'));
+    const { canOverwrite } = await prompts({
+        type: 'confirm',
+        name: 'canOverwrite',
+        message: `${locationText}\n  ${promptText}`,
+        initial: false,
+    });
+    return canOverwrite;
 }
 
-function pickExisting(source, keys) {
-    return keys.reduce((acc, key) => {
-        if (key in source)
-            acc[key] = source[key];
-        return acc;
-    }, {});
+async function promptProjectFolderAsync(defaultValue) {
+    const { projectFolder } = await prompts({
+        type: 'text',
+        name: 'projectFolder',
+        message: t('projectFolder.prompt'),
+        initial: defaultValue,
+        validate: (value) => {
+            return value.trim().length === 0
+                ? t('validation.required')
+                : true;
+        },
+    });
+    return projectFolder.trim();
 }
-const devDependencies = cliPackage.devDependencies;
-const pickDependencies = (keys) => pickExisting(devDependencies, keys);
-function createConfig(templateDir, options = {}) {
-    const { styleGuide = 'default', addVitest, additionalConfigs = [], } = options;
-    const pkg = {
-        devDependencies: pickDependencies([
-            '@eslint/js',
-            '@stylistic/eslint-plugin',
-            'eslint',
-            'globals',
-            'typescript-eslint',
-        ]),
-        scripts: {},
-    };
-    const fileExtensions = ['ts', 'mts', 'tsx'];
-    if (addVitest) {
-        additionalConfigs.unshift({
-            devDependencies: pickDependencies(['@vitest/eslint-plugin']),
-        });
+
+/**
+ * Асинхронно проверяет, существует ли файл или директория по указанному пути.
+ *
+ * Использует `fs.access`, чтобы обойти ограничения `fs.existsSync` в асинхронной среде.
+ *
+ * @param path - Путь к файлу или директории.
+ * @returns `true`, если путь существует и доступен, иначе `false`.
+ *
+ * @since 0.4.0
+ *
+ **/
+async function isExistsAsync(path) {
+    try {
+        await fs.access(path);
+        return true;
     }
-    for (const config of additionalConfigs) {
-        deepMerge(pkg.devDependencies, config.devDependencies ?? {});
+    catch (e) {
+        if (e && typeof e === 'object' && 'code' in e && e.code === 'ENOENT')
+            return false;
+        throw e;
     }
-    const templateData = {
-        styleGuide,
-        addVitest,
-        fileExtensions,
-    };
-    function renderEjsEntry(fileName) {
-        const filePath = resolve(templateDir, fileName);
-        return [
-            fileName.replace(/\.ejs$/, ''),
-            renderEjs(filePath, templateData),
-        ];
-    }
-    const entries = [
-        renderEjsEntry('eslint.config.mjs.ejs'),
-    ];
-    return {
-        pkg,
-        files: Object.fromEntries(entries),
-    };
 }
-function renderEslintConfig(templateRoot, rootDir, options = {}) {
-    const { addVitest } = options;
-    const templateDir = resolve(templateRoot, 'eslint');
-    const { pkg, files } = createConfig(templateDir, {
-        styleGuide: 'default',
-        addVitest,
-    });
-    const targetPkgPath = resolve(rootDir, 'package.json');
-    renderJson(pkg, targetPkgPath, result => sortDependencies(result));
-    for (const [fileName, content] of Object.entries(files)) {
-        const fullPath = resolve(rootDir, fileName);
-        writeFileSync(fullPath, content, 'utf-8');
-    }
+async function isDirEmptyAsync(targetDir) {
+    const files = await fs.readdir(targetDir);
+    return !files.length || (files.length === 1 && files[0] === '.git');
 }
-
-function runCommand(command, args, options) {
-    return new Promise((resolve, reject) => {
-        const runner = spawn(command, args, {
-            cwd: options.root,
-            stdio: 'inherit',
-            shell: true,
-            ...options,
-        });
-        runner.on('exit', (code) => {
-            console.log();
-            if (code) {
-                console.log(` ${command} FAILED...`);
-                console.log();
-                reject(new Error());
-            }
-            else {
-                resolve();
-            }
+async function clearDirAsync(targetDir) {
+    for (const filename of await fs.readdir(targetDir)) {
+        if (filename === '.git')
+            continue;
+        await fs.rm(resolve(targetDir, filename), {
+            recursive: true,
+            force: true,
         });
-    });
+    }
 }
 
-function getRunningPackageManager() {
-    const userAgent = process.env.npm_config_user_agent;
-    if (!userAgent)
-        return;
-    const [name, version] = userAgent.split(' ')[0].split('/');
+async function resolveProjectContextAsync(selection, options = {}) {
+    const { cwd = process.cwd(), barebone, } = options;
+    const projectName = options.projectFolder || await promptProjectFolderAsync(`wb-mirta-${selection.type}`);
+    if (options.projectFolder)
+        logger.step(`${t('projectFolder.prompt')}: ${options.projectFolder}`);
+    const projectRoot = resolve(cwd, projectName);
+    if (!projectRoot.startsWith(cwd.endsWith('/') ? cwd : cwd + sep) && projectRoot !== cwd)
+        throw CreationError.get('project.outsideRoot');
+    const isExists = await isExistsAsync(projectRoot);
+    const isEmpty = !isExists || await isDirEmptyAsync(projectRoot);
+    let shouldOverwrite = false;
+    if (!isEmpty) {
+        shouldOverwrite
+            = options.forceOverwrite === true || await confirmOverwriteAsync(projectRoot);
+        if (!shouldOverwrite)
+            throw new OperationCanceledError();
+    }
+    const templates = await resolveTemplateSequenceAsync(selection);
     return {
-        name,
-        version,
+        rootDir: projectRoot,
+        name: projectName,
+        shouldOverwrite: shouldOverwrite,
+        shouldCreate: !isExists,
+        templates: templates,
+        barebone: barebone,
     };
 }
-const runningPackageManager = getRunningPackageManager();
-async function installDependencies(scope) {
-    if (!scope.packageManager)
-        return;
-    const args = ['install'];
-    await runCommand(scope.packageManager, args, { root: scope.projectRoot });
-}
-
-const locale = getLocale();
-const finalMessageEn = `\
-To get started, open your project in VSCode or other code editor.
-Documentation can be found at: https://dzen.ru/wihome
-
-Please, give a star on GitHub if you appreciate this work:
-https://github.com/wb-mirta/core
-`;
-const finalMessageRu = `\
-Откройте проект в VSCode или другом подходящем редакторе.
-Документация публикуется на Дзене: https://dzen.ru/wihome
-
-Если вам нравится фреймворк, поставьте ему звёздочку на Гитхабе:
-https://github.com/wb-mirta/core
-
-Поблагодарить разработчика можно через Boosty:
-https://boosty.to/wihome/donate
 
-Также доступен сервис для безналичных чаевых от Т‑Банка и CloudPayments:
-https://pay.cloudtips.ru/p/58512cca
-`;
-const finalMessage = locale === 'ru-RU'
-    ? finalMessageRu
-    : finalMessageEn;
-
-const { dim, red, yellow } = chalk;
-const templatesPath = './templates';
-const messages = await getLocalized();
-const featureOptions = [
-    {
-        value: 'eslint',
-        label: messages.addEslint.message,
-        hint: messages.addEslint.hint,
+const initialSchema = ({
+    // === Common options ===
+    version: {
+        type: 'boolean',
+        short: 'v',
     },
-    {
-        value: 'store',
-        label: messages.addStore.message,
-        hint: messages.addStore.hint,
+    help: {
+        type: 'boolean',
+        short: 'h',
     },
-    {
-        value: 'vitest',
-        label: messages.addVitest.message,
-        hint: messages.addVitest.hint,
+    locale: {
+        type: 'string',
     },
-];
-const { prompt, cancel, step, message, inlineSub } = usePrompts(messages);
-function isValidPackageName(packageName) {
-    return /^(?:@[a-z0-9-*~][a-z0-9-*._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/
-        .test(packageName);
-}
-function toValidPackageName(packageName) {
-    return packageName
-        .trim()
-        .toLowerCase()
-        .replace(/\s+/g, '-')
-        .replace(/^[._]+/, '')
-        .replace(/[^a-z0-9-~]+/g, '-');
-}
+    template: {
+        type: 'string',
+    },
+    force: {
+        type: 'boolean',
+    },
+    bare: {
+        type: 'boolean',
+    },
+});
 async function run() {
-    const cwd = process.cwd();
-    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);
-    }
+    const args = createStagedArgs(process.argv.slice(2));
+    const parseResult = args.parse(initialSchema);
+    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}`);
-        process.exit(0);
+        return;
+    }
+    if (argv.help) {
+        console.log(getHelpMessage());
+        return;
     }
-    // Если какой-либо функционал указан заранее, пропустить этот вопрос.
-    const isFeatureFlagsUsed = Object.keys(featureFlags)
-        .some(flag => typeof argv[flag] === 'boolean');
-    let targetDir = positionals[0];
-    const hasPositionalDir = targetDir && targetDir !== '.';
-    const defaultProjectName = hasPositionalDir ? targetDir : 'wb-rules-mirta';
-    const shouldOverwrite = argv.force;
-    const sshAddress = parseUrl(argv.ssh);
-    const sshDefaultUser = 'root';
-    const sshDefaultHost = '10.200.200.1';
-    const sshDefaultPort = '22';
-    const sshFullyDefined = !!(sshAddress.username && sshAddress.hostname);
-    const scope = {
-        projectName: defaultProjectName,
-        projectRoot: '',
-        packageName: defaultProjectName,
-        shouldOverwrite,
-        features: [],
-        sshUsername: sshAddress.username,
-        sshHostname: sshAddress.hostname,
-        sshPort: sshAddress.port,
-        rutoken: argv.rutoken,
-    };
     console.log(banner);
-    console.log(messages.title);
+    console.log(t('title'));
     console.log();
-    intro(chalk.bgBlackBright.black(` ${messages.captions.intro} `));
-    if (!targetDir) {
-        const answer = await prompt(text({
-            message: messages.projectName.message,
-            placeholder: defaultProjectName,
-            defaultValue: defaultProjectName,
-            validate: (value) => {
-                if (value.length !== 0 && value.trim().length === 0)
-                    return messages.validation.required;
-            },
-        }));
-        targetDir = scope.projectName = scope.packageName = answer.trim();
-    }
-    const root = scope.projectRoot = resolve(cwd, targetDir);
-    const baseName = basename(root);
-    if (hasPositionalDir) {
-        step(`${messages.projectName.message}\n${dim(baseName)}`);
-    }
-    // Защита от выхода за пределы рабочей директории.
-    if (!root.startsWith(cwd)) {
-        cancel(messages.errors.rootIsNotRelative);
-        process.exit(1);
-    }
-    if (!isValidPackageName(targetDir)) {
-        scope.packageName = await prompt(text({
-            message: messages.packageName.message,
-            initialValue: toValidPackageName(baseName),
-            validate: value => isValidPackageName(value)
-                ? undefined
-                : messages.packageName.errorMessage,
-        }));
-    }
-    if (!canSkipDir(targetDir) && !shouldOverwrite) {
-        scope.shouldOverwrite = await prompt(confirm({
-            message: `${targetDir === '.'
-                ? messages.shouldOverwrite.directory.current
-                : messages.shouldOverwrite.directory.target} "${baseName}" ${messages.shouldOverwrite.message} ${red(messages.shouldOverwrite.confirmDelete)}`,
-            initialValue: false,
-        }));
-        if (!scope.shouldOverwrite) {
-            cancel();
-            process.exit(0);
-        }
-    }
-    message(chalk.bgBlackBright.black(` ${messages.captions.deploy} `));
-    if (!scope.sshUsername) {
-        scope.sshUsername = await prompt(text({
-            message: messages.ssh.username,
-            placeholder: sshDefaultUser,
-            defaultValue: sshDefaultUser,
-            validate: (value) => {
-                if (value.length !== 0 && value.trim().length === 0)
-                    return messages.validation.required;
-            },
-        }));
-    }
-    else {
-        step(`${messages.ssh.username}\n${dim(scope.sshUsername)}`);
-    }
-    if (!scope.sshHostname) {
-        scope.sshHostname = await prompt(text({
-            message: messages.ssh.host,
-            placeholder: sshDefaultHost,
-            defaultValue: sshDefaultHost,
-            validate: (value) => {
-                if (value.length !== 0 && value.trim().length === 0)
-                    return messages.validation.required;
-            },
-        }));
-    }
-    else {
-        step(`${messages.ssh.host}\n${dim(scope.sshHostname)}`);
-    }
-    if (!sshFullyDefined && !scope.sshPort) {
-        scope.sshPort = await prompt(text({
-            message: messages.ssh.port,
-            placeholder: sshDefaultPort,
-            defaultValue: sshDefaultPort,
-            validate: (value) => {
-                if (value.length !== 0 && value.trim().length === 0)
-                    return messages.validation.required;
-            },
-        }));
-    }
-    else if (scope.sshPort) {
-        step(`${messages.ssh.port}\n${dim(scope.sshPort)}`);
-    }
-    if (!sshFullyDefined && !scope.rutoken) {
-        scope.rutoken = await prompt(confirm({
-            message: `${messages.ssh.useRutoken} ${dim(messages.accent.ifConfigured)}`,
-            initialValue: false,
-        }));
-    }
-    else if (scope.rutoken) {
-        step(`${messages.ssh.useRutoken} ${dim(messages.accent.ifConfigured)}\n${dim('Yes')}`);
-    }
-    if (!isFeatureFlagsUsed) {
-        scope.features = await prompt(multiselect({
-            message: `${messages.featureSelection.message}${inlineSub(dim(messages.featureSelection.hint))}`,
-            options: featureOptions,
-            required: false,
-        }));
-    }
-    const { features } = scope;
-    const addEslint = argv.eslint === true || features.includes('eslint');
-    const addStore = argv.store === true || features.includes('store');
-    const addVitest = argv.vitest === true || features.includes('vitest');
-    // Очистка целевой директории
-    if (fs.existsSync(root)) {
-        if (scope.shouldOverwrite)
-            emptyDir(root);
-    }
-    else {
-        fs.mkdirSync(root);
-    }
-    step(`${messages.status.scaffolding} ${yellow(root)}`);
-    const pkg = {
-        name: scope.packageName,
-        version: '0.0.0',
-        scripts: {
-            'wb:deploy': '',
-        },
-    };
-    const deployScript = ['rsync'];
-    if (process.platform === 'win32') {
-        // Run rsync trough WSL on Windows systems.
-        deployScript.unshift('wsl ');
-    }
-    if (scope.rutoken || scope.sshPort) {
-        deployScript.push(' -e \'ssh');
-        if (scope.rutoken)
-            deployScript.push(' -I /usr/lib/librtpkcs11ecp.so');
-        if (scope.sshPort)
-            deployScript.push(` -p ${scope.sshPort}`);
-        deployScript.push('\'');
-    }
-    deployScript.push(' -rltzvgO --progress --delete --exclude=\'alarms.conf\'');
-    deployScript.push(' --groupmap=\'*:developers\' dist/es5/*');
-    deployScript.push(` '${scope.sshUsername}@${scope.sshHostname}:/mnt/data/etc/'`);
-    pkg.scripts['wb:deploy'] = deployScript.join('');
-    fs.writeFileSync(resolve(root, 'package.json'), JSON.stringify(pkg, null, 2));
-    const templateRoot = fileURLToPath(new URL(templatesPath, import.meta.url));
-    const render = function (templateName) {
-        const templateDir = resolve(templateRoot, templateName);
-        renderTemplate(templateDir, root);
-    };
-    // Create basic project structure
-    render('base');
-    // Add TypeScript support
-    render('config/typescript');
-    if (addEslint) {
-        renderEslintConfig(templateRoot, root, {
-            addVitest,
-        });
-        render('config/eslint');
-    }
-    if (!argv.bare) {
-        render('example/base');
+    // Определяем тип шаблона - по аргументам или через вопрос пользователю.
+    const selection = await pickProjectAsync(argv.template?.toLowerCase());
+    const runner = await resolveRunnerAsync(selection.type);
+    const context = await resolveProjectContextAsync(selection, {
+        projectFolder: positionals[0],
+        forceOverwrite: argv.force,
+        barebone: argv.bare,
+    });
+    await runner.runAsync(runnerArgs, context);
+    console.log();
+    console.log(getFinalMessage());
+}
+run().catch((e) => {
+    if (e instanceof PromptCanceledError || e instanceof OperationCanceledError) {
+        logger.cancel(t('step.canceled'));
     }
-    if (addStore) {
-        render('config/store');
-        if (!argv.bare) {
-            render('example/store');
-        }
+    else if (e instanceof CreationError) {
+        logger.error(e.message);
     }
-    if (addVitest) {
-        render('config/vitest');
-        if (!argv.bare) {
-            render('example/vitest/base');
-            if (addStore) {
-                render('example/vitest/store');
-            }
-        }
+    else if (e instanceof Error) {
+        // Unexpected internal error - rethrow to preserve stack trace
+        throw e;
     }
-    step(formatSuccess(messages.status.scaffolded, messages.status.success));
-    scope.packageManager ??= await prompt(select({
-        message: `${messages.dependencies.question} ${dim(messages.accent.recommended)}`,
-        options: runningPackageManager
-            ? [
-                {
-                    value: runningPackageManager.name,
-                    label: `${messages.dependencies.current.message} ${runningPackageManager.name}`,
-                },
-                {
-                    value: '',
-                    label: messages.dependencies.no.message,
-                },
-            ]
-            : [
-                {
-                    value: 'pnpm',
-                    label: messages.dependencies.pnpm.message,
-                    hint: messages.dependencies.pnpm.hint,
-                },
-                {
-                    value: 'yarn',
-                    label: messages.dependencies.yarn.message,
-                },
-                {
-                    value: 'npm',
-                    label: messages.dependencies.npm.message,
-                },
-                {
-                    value: 'bun',
-                    label: messages.dependencies.bun.message,
-                },
-                {
-                    value: '',
-                    label: messages.dependencies.no.message,
-                },
-            ],
-    }));
-    if (scope.packageManager) {
-        outro(messages.status.installingDependencies);
-        await installDependencies(scope);
+    else if (typeof e === 'string') {
+        logger.error(e);
     }
-    console.log();
-    console.log(finalMessage);
-}
-run().catch((e) => {
-    console.error(e);
     process.exit(1);
 });
+
+export { FEATURE_ORIGIN_CLI as F, OperationCanceledError as O, assertNoParseErrors as a, clearDirAsync as c, isExistsAsync as i, logger as l, prompts as p, t };