create-mirta 0.3.4 → 0.4.3

package/dist/resolver.mjs

@@ -0,0 +1,843 @@
+import { isObject, isPlainObject } from '@mirta/basics';
+import fs, { glob } from 'node:fs/promises';
+import { join, relative, basename } from 'node:path';
+import { i as isExistsAsync, F as FEATURE_ORIGIN_CLI, t, p as prompts, l as logger, O as OperationCanceledError } from './index.mjs';
+import { createScanner } from 'jsonc-parser';
+import chalk from 'chalk';
+import { spawn } from 'node:child_process';
+
+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];
+            });
+        }
+    });
+    return {
+        ...packageJson,
+        ...sorted,
+    };
+}
+
+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);
+        }
+        else if (isObject(oldVal) && isObject(newVal)) {
+            target[key] = deepMerge(oldVal, newVal);
+        }
+        else {
+            target[key] = newVal;
+        }
+    }
+    return target;
+}
+
+function parse(content) {
+    // TODO: Добавить валидацию.
+    return JSON.parse(content);
+}
+async function renderAsync$1(fromPath, toPath, content, resultHandler) {
+    const targetContent = await fs.readFile(toPath, 'utf-8');
+    const targetObject = parse(targetContent);
+    const sourceObject = content !== undefined
+        ? parse(content)
+        : parse(await fs.readFile(fromPath, 'utf-8'));
+    let mergedObject = deepMerge(targetObject, sourceObject);
+    if (resultHandler)
+        mergedObject = resultHandler(mergedObject);
+    await fs.writeFile(toPath, JSON.stringify(mergedObject, null, 2) + '\n');
+}
+
+function getReadable(token) {
+    switch (token) {
+        case 10 /* SyntaxKind.StringLiteral */:
+            return 'string';
+        case 11 /* SyntaxKind.NumericLiteral */:
+            return 'number';
+        case 8 /* SyntaxKind.TrueKeyword */:
+            return 'true';
+        case 9 /* SyntaxKind.FalseKeyword */:
+            return 'false';
+        case 7 /* SyntaxKind.NullKeyword */:
+            return 'null';
+        case 2 /* SyntaxKind.CloseBraceToken */:
+            return '}';
+        case 4 /* SyntaxKind.CloseBracketToken */:
+            return ']';
+        case 5 /* SyntaxKind.CommaToken */:
+            return ',';
+        case 6 /* SyntaxKind.ColonToken */:
+            return ':';
+        default:
+            return 'unknown';
+    }
+}
+function parseJsonc(text) {
+    const scanner = createScanner(text);
+    const comments = [];
+    let token = scanner.scan();
+    // === Вспомогательные функции ===
+    const advance = () => (token = scanner.scan());
+    const skipTrivia = () => {
+        while (token === 12 /* SyntaxKind.LineCommentTrivia */
+            || token === 13 /* SyntaxKind.BlockCommentTrivia */
+            || token === 14 /* SyntaxKind.LineBreakTrivia */
+            || token === 15 /* SyntaxKind.Trivia */) {
+            if (token === 12 /* SyntaxKind.LineCommentTrivia */
+                || token === 13 /* SyntaxKind.BlockCommentTrivia */) {
+                comments.push(scanner.getTokenValue().trim());
+            }
+            advance();
+        }
+    };
+    // Сканим и пропускаем тривиалы
+    const next = () => {
+        advance();
+        skipTrivia();
+        return token;
+    };
+    const takeComments = () => {
+        if (comments.length === 0)
+            return undefined;
+        const result = [...comments];
+        comments.length = 0;
+        return result;
+    };
+    const nodeWithComments = (node = {}) => {
+        const commentsBefore = takeComments();
+        if (commentsBefore)
+            node.comments = commentsBefore;
+        return node;
+    };
+    const consume = (expected, isOptional) => {
+        if (token === expected)
+            return next();
+        if (!isOptional)
+            throw new Error(`Expected ${getReadable(expected)}, got ${scanner.getTokenValue()} at position ${scanner.getPosition()}`);
+    };
+    // === Основные парсеры ===
+    const parseValue = () => {
+        const node = nodeWithComments({});
+        switch (token) {
+            case 10 /* SyntaxKind.StringLiteral */:
+                node.value = scanner.getTokenValue();
+                next();
+                break;
+            case 11 /* SyntaxKind.NumericLiteral */:
+                node.value = Number(scanner.getTokenValue());
+                next();
+                break;
+            case 8 /* SyntaxKind.TrueKeyword */:
+                node.value = true;
+                next();
+                break;
+            case 9 /* SyntaxKind.FalseKeyword */:
+                node.value = false;
+                next();
+                break;
+            case 7 /* SyntaxKind.NullKeyword */:
+                node.value = null;
+                next();
+                break;
+            case 1 /* SyntaxKind.OpenBraceToken */:
+                node.value = parseObject();
+                break;
+            case 3 /* SyntaxKind.OpenBracketToken */:
+                node.value = parseArray();
+                break;
+            default:
+                throw new Error(`Unexpected ${getReadable(token)} at position ${scanner.getPosition()}`);
+        }
+        return node;
+    };
+    const parseObject = () => {
+        next(); // skip '{'
+        const result = {};
+        while (token !== 2 /* SyntaxKind.CloseBraceToken */ && token !== 17 /* SyntaxKind.EOF */) {
+            // Проверяем, что текущий токен — строка
+            if (token !== 10 /* SyntaxKind.StringLiteral */)
+                throw new Error(`Expected key at position ${scanner.getPosition()}`);
+            // Сохраняем значение ДО продвижения
+            const key = scanner.getTokenValue();
+            next();
+            consume(6 /* SyntaxKind.ColonToken */);
+            result[key] = parseValue();
+            consume(5 /* SyntaxKind.CommaToken */, true);
+        }
+        consume(2 /* SyntaxKind.CloseBraceToken */);
+        return result;
+    };
+    const parseArray = () => {
+        next(); // skip '['
+        const result = [];
+        while (token !== 4 /* SyntaxKind.CloseBracketToken */ && token !== 17 /* SyntaxKind.EOF */) {
+            result.push(parseValue());
+            if (token === 5 /* SyntaxKind.CommaToken */) {
+                next();
+            }
+        }
+        consume(4 /* SyntaxKind.CloseBracketToken */);
+        return result;
+    };
+    // === Запуск ===
+    skipTrivia();
+    if (token === 1 /* SyntaxKind.OpenBraceToken */) {
+        comments.length = 0; // сброс комментариев до корневого объекта
+        return parseObject();
+    }
+    throw new Error('Root must be object');
+}
+
+function serializeNode(value, indentSize = 0) {
+    const indent = '  '.repeat(indentSize);
+    const nextIndent = '  '.repeat(indentSize + 1);
+    if (value === null)
+        return 'null';
+    if (typeof value === 'object') {
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                return '[]';
+            const items = value.map((item) => {
+                const comments = item.comments ?? [];
+                const serializedValue = serializeNode(item.value, indentSize + 1);
+                const commentLines = comments.map(c => `${nextIndent}${c}`).join('\n');
+                return commentLines
+                    ? `${commentLines}\n${nextIndent}${serializedValue}`
+                    : `${nextIndent}${serializedValue}`;
+            });
+            return `[\n${items.join(`,\n`)}\n${indent}]`;
+        }
+        // Это JsoncContainer
+        const container = value;
+        const keys = Object.keys(container);
+        if (keys.length === 0)
+            return '{}';
+        const entries = keys.map((key) => {
+            const node = container[key];
+            const comments = node.comments?.map(c => `${nextIndent}${c}`).join('\n');
+            const serializedValue = serializeNode(node.value, indentSize + 1);
+            const field = `${nextIndent}${JSON.stringify(key)}: ${serializedValue}`;
+            return [comments, field].filter(Boolean).join('\n');
+        });
+        return `{\n${entries.join(',\n')}\n${indent}}`;
+    }
+    // Простые значения
+    return JSON.stringify(value);
+}
+function stringify(container) {
+    return serializeNode(container, 0);
+}
+
+async function renderAsync(fromPath, toPath, content) {
+    const targetContent = await fs.readFile(toPath, 'utf-8');
+    const targetObject = parseJsonc(targetContent);
+    const sourceObject = content !== undefined
+        ? parseJsonc(content)
+        : parseJsonc(await fs.readFile(fromPath, 'utf-8'));
+    const mergedObject = deepMerge(targetObject, sourceObject);
+    await fs.writeFile(toPath, stringify(mergedObject) + '\n');
+}
+
+/** Папки и файлы, игнорируемые при обходе шаблона. */
+const IGNORED_DIRS = [
+    'node_modules/**',
+    '.git/**',
+    'dist/**',
+    '*.log',
+];
+/** JSONC-файлы, которые мержатся с существующими при копировании. */
+const KNOWN_JSONC = [
+    'tsconfig.json',
+    'mirta.config.json',
+];
+/** JSON-файлы, которые мержатся с существующими при копировании. */
+const KNOWN_JSON = [
+    'extensions.json',
+    'settings.json',
+    'tasks.json',
+];
+/**
+ * Асинхронно перебирает файлы директории, исключая {@link IGNORED_DIRS}.
+ *
+ * @param rootDir Корневая директория шаблона.
+ * @yields Объекты {@link Dirent} для каждого элемента.
+ *
+ * @since 0.4.0
+ *
+ **/
+async function* getDirectoryEntriesAsync(rootDir) {
+    for await (const entry of glob('**/*', {
+        cwd: rootDir,
+        exclude: IGNORED_DIRS,
+        withFileTypes: true,
+    })) {
+        const relativePath = relative(rootDir, entry.parentPath);
+        yield {
+            relativePath,
+            name: entry.name,
+            isDirectory: entry.isDirectory(),
+        };
+    }
+}
+const supportedTypes = ['string', 'number', 'boolean'];
+function toTemplateData(source) {
+    const result = {};
+    // Инициализация: корневые свойства
+    const stack = Object.entries(source);
+    let nextItem;
+    while (stack.length > 0 && (nextItem = stack.pop())) {
+        const [path, value] = nextItem; // DFS
+        const valueType = typeof value;
+        if (supportedTypes.includes(valueType)) {
+            result[path] = value;
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (typeof item === 'string')
+                    result[`${path}.${item}`] = true;
+            }
+            continue;
+        }
+        if (!isPlainObject(value))
+            continue;
+        const entries = Object.entries(value);
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const [key, nextValue] = entries[i];
+            stack.push([`${path}.${key}`, nextValue]);
+        }
+    }
+    return result;
+}
+/**
+ * Заменяет в строке `{{key}}` и `{{#if key}}...{{/if key}}` на значения параметра `data`.
+ *
+ * @param content Текст с шаблонами.
+ * @param data Данные для подстановки.
+ * @returns Обработанный текст.
+ *
+ * @since 0.4.0
+ *
+ **/
+function applyTemplatedText(content, data) {
+    if (!content.includes('{{'))
+        return content;
+    // Сначала обрабатываем условные блоки: {{#if key}}...{{/if key}}
+    content = content.replace(/{{#if\s+([a-zA-Z0-9_.]+)}}\n?([\s\S]*?)\n?{{\/if\s+\1}}/g, (_, key, blockContent) => {
+        return key in data ? applyTemplatedText(blockContent, data) : '';
+    });
+    // Затем подставляем переменные: {{key}}
+    content = content.replace(/{{([a-zA-Z0-9_.]+)}}/g, (original, key) => {
+        return key in data ? String(data[key]) : original;
+    });
+    return content;
+}
+/**
+ * Копирует или обрабатывает файл в целевую директорию.
+ * Учитывает специальные случаи: `package.json`, `.gitignore`, скрытые файлы.
+ *
+ * @param fromPath Путь к исходному файлу.
+ * @param toPath Путь к целевому файлу.
+ * @param content Опциональное содержимое (если файл шаблонизирован).
+ *
+ * @since 0.4.0
+ *
+ **/
+async function renderFileAsync(fromPath, toPath, content) {
+    const toFileName = basename(toPath);
+    // Мерж package.json с сортировкой зависимостей
+    if (toFileName === 'package.json' && await isExistsAsync(toPath)) {
+        await renderAsync$1(fromPath, toPath, content, json => sortDependencies(json));
+        return;
+    }
+    // Мерж других известных JSON
+    if (KNOWN_JSON.includes(toFileName) && await isExistsAsync(toPath)) {
+        await renderAsync$1(fromPath, toPath, content);
+        return;
+    }
+    // Мерж известных JSONC
+    if (KNOWN_JSONC.includes(toFileName) && await isExistsAsync(toPath)) {
+        await renderAsync(fromPath, toPath, content);
+        return;
+    }
+    // Дописывание в .gitignore
+    if (toFileName === '.gitignore' && await isExistsAsync(toPath)) {
+        const oldContent = await fs.readFile(toPath, 'utf-8');
+        const newContent = content ?? await fs.readFile(fromPath, 'utf-8');
+        const separator = oldContent.endsWith('\n') ? '' : '\n';
+        await fs.writeFile(toPath, oldContent + separator + newContent);
+        return;
+    }
+    // Запись обработанного контента
+    if (content) {
+        await fs.writeFile(toPath, content);
+        return;
+    }
+    // Для остальных файлов — простое копирование
+    await fs.copyFile(fromPath, toPath);
+}
+/**
+ * Обрабатывает `.tt`-файл: шаблонизирует и передаёт в {@link renderFileAsync}.
+ *
+ * @param fromPath Путь к `.tt`-файлу.
+ * @param toPath Путь к целевому файлу (без `.tt`).
+ * @param data Данные для шаблона.
+ *
+ * @since 0.4.0
+ *
+ **/
+async function renderFileTemplatedAsync(fromPath, toPath, data) {
+    const content = await fs.readFile(fromPath, 'utf-8');
+    await renderFileAsync(fromPath, toPath, applyTemplatedText(content, data));
+}
+function unescapeDot(path) {
+    // Экранированные точки заменяются в любом месте пути.
+    return path.replace(/_\./g, '.');
+}
+/**
+ * Применяет шаблон из `fromRoot` в `toRoot` с подстановкой данных.
+ * Поддерживает `.tt`, `_ → .`, мерж JSON.
+ *
+ * @param fromRoot Корень шаблона.
+ * @param toRoot Целевая директория.
+ * @param data Данные для шаблонов.
+ *
+ * @since 0.4.0
+ *
+ **/
+async function renderDirectoryAsync(fromRoot, toRoot, data) {
+    for await (const entry of getDirectoryEntriesAsync(fromRoot)) {
+        // === 1. Переданные директории воссоздаём в целевом расположении ===
+        if (entry.isDirectory) {
+            const toPath = unescapeDot(applyTemplatedText(join(toRoot, entry.relativePath, entry.name), data));
+            await fs.mkdir(toPath, { recursive: true });
+            continue;
+        }
+        // === 2. Обрабатываем файлы ===
+        // Формируем путь к исходному файлу.
+        const fromPath = join(fromRoot, entry.relativePath, entry.name);
+        // Формируем путь к целевому файлу.
+        const toPath = unescapeDot(applyTemplatedText(join(toRoot, entry.relativePath, entry.name), data));
+        // Если файл шаблонизирован, обрабатываем его особым образом.
+        if (toPath.endsWith('.tt')) {
+            await renderFileTemplatedAsync(fromPath, toPath.slice(0, -3), data);
+            continue;
+        }
+        await renderFileAsync(fromPath, toPath);
+    }
+}
+
+const featurePriority = {
+    'optional': 0,
+    'recommended': 1,
+    'required': 2,
+    'blocked': 3,
+};
+function assertIsFeatureEntry(entry) {
+    const [feature, state] = entry;
+    if (typeof feature !== 'string')
+        throw new Error(`Invalid feature name: expected string, got ${typeof feature}`);
+    if (typeof state !== 'string')
+        throw new Error(`Invalid feature state: expected string, got ${typeof state}`);
+    if ((!(state in featurePriority)))
+        throw new Error(`Unknown feature state "${state}", supported values: ${Object.keys(featurePriority).join(', ')}`);
+}
+function extractFeatures(sequence) {
+    const result = {};
+    for (const template of sequence) {
+        if (!template.features?.global)
+            continue;
+        for (const entry of Object.entries(template.features.global)) {
+            assertIsFeatureEntry(entry);
+            const [featureName, state] = entry;
+            if (!(featureName in result)) {
+                result[featureName] = { state, origin: template.name };
+                continue;
+            }
+            const { state: oldState, origin } = result[featureName];
+            if (state === 'required' && oldState === 'blocked')
+                throw new Error(`Unable to require feature "${featureName}": blocked by "${origin}"`);
+            if (state === 'blocked' && oldState === 'required')
+                throw new Error(`Unable to block feature "${featureName}": required by "${origin}"`);
+            if (featurePriority[state] > featurePriority[oldState]) {
+                result[featureName] = { state, origin: template.name };
+            }
+        }
+    }
+    return result;
+}
+
+async function selectFeaturesAsync(features) {
+    const required = [];
+    const choices = [];
+    for (const [featureName, { state, origin }] of Object.entries(features)) {
+        const isRequired = state === 'required';
+        const isBlocked = state === 'blocked';
+        const isRecommended = state === 'recommended';
+        if (isRequired)
+            required.push(featureName);
+        if (isRequired || origin === FEATURE_ORIGIN_CLI)
+            continue;
+        let hint = '';
+        if (isRecommended)
+            hint = ` (${t('hint.recommended').toLowerCase()})`;
+        choices.push({
+            title: t.plain(`features.${featureName}.name`),
+            description: t.plain(`features.${featureName}.description`) + hint,
+            value: featureName,
+            selected: isRecommended,
+            disabled: isBlocked,
+        });
+    }
+    const { selected } = await prompts({
+        type: 'multiselect',
+        name: 'selected',
+        message: t('features.select'),
+        instructions: '\n' + chalk.dim(t('features.instructions')),
+        warn: t('hint.blocked'),
+        choices: choices,
+    });
+    return [
+        ...required,
+        ...selected,
+    ];
+}
+
+function overrideState(key, isEnabled, features) {
+    const feature = features[key];
+    if (!feature) {
+        if (isEnabled)
+            logger.warn(t('feature.skipped', { feature: key }));
+        return false;
+    }
+    if (isEnabled) {
+        if (feature.state === 'blocked')
+            throw new Error(`Feature ${key} blocked by ${feature.origin}`);
+        feature.state = 'required';
+        feature.origin = FEATURE_ORIGIN_CLI;
+    }
+    else {
+        if (feature.state === 'required')
+            throw new Error(`Feature ${key} required by ${feature.origin}`);
+        feature.state = 'blocked';
+        feature.origin = FEATURE_ORIGIN_CLI;
+    }
+    return true;
+}
+async function resolveFeaturesAsync(context, overrides = {}) {
+    const features = extractFeatures(context.templates);
+    for (const [key, value] of Object.entries(overrides)) {
+        if (value === undefined)
+            continue;
+        overrideState(key, !!value, features);
+    }
+    return await selectFeaturesAsync(features);
+}
+
+/**
+ * Имя пользователя по умолчанию для SSH-подключения.
+ *
+ * Используется, когда значение отсутствует в строке подключения.
+ *
+ * @since 0.4.0
+ *
+ **/
+const DEFAULT_SSH_USERNAME = 'root';
+/**
+ * Адрес хоста по умолчанию для подключения к контроллеру.
+ *
+ * Используется, когда значение отсутствует в строке подключения.
+ *
+ * @since 0.4.0
+ *
+ **/
+const DEFAULT_SSH_HOSTNAME = '192.168.42.1';
+/**
+ * Стандартный порт SSH.
+ *
+ * @since 0.4.0
+ *
+ **/
+const KNOWN_SSH_PORT = 22;
+
+const urlRegex = /^(?:(?<username>[a-z][-a-z0-9_.]*)@)?(?:(?<hostname>[^:@\s]+))?(?::(?<port>\d+))?$/;
+const usernameRegex = /^[a-z][-a-z0-9_.]*$/;
+const hostnameRegex = /^[^:@\s]+$/;
+function parseUrl(input) {
+    if (!input)
+        return {};
+    return (urlRegex.exec(input))?.groups ?? {};
+}
+
+const rutokenLib = 'pkcs11=/opt/aktivco/rutokenecp/amd64/librtpkcs11ecp.so';
+function createConnectionString(input) {
+    let connection = `ssh://${input.username}@${input.hostname}`;
+    if (Number(input.port) !== KNOWN_SSH_PORT)
+        connection += `:${input.port}`;
+    if (input.rutoken)
+        connection += `;${rutokenLib}`;
+    return connection;
+}
+async function resolveConnectionStringAsync(input, rutoken) {
+    if (input) {
+        const parsed = parseUrl(input);
+        return createConnectionString({
+            username: parsed.username || DEFAULT_SSH_USERNAME,
+            hostname: parsed.hostname || DEFAULT_SSH_HOSTNAME,
+            port: parsed.port || KNOWN_SSH_PORT,
+            rutoken,
+        });
+    }
+    const questions = [
+        {
+            type: 'text',
+            name: 'username',
+            message: t('ssh.username'),
+            initial: DEFAULT_SSH_USERNAME,
+            validate: (value) => {
+                if (value.trim().length === 0)
+                    return t('validation.required');
+                if (!usernameRegex.test(value))
+                    return t('validation.invalidFormat');
+                return true;
+            },
+        },
+        {
+            type: 'text',
+            name: 'hostname',
+            message: t('ssh.hostname'),
+            initial: DEFAULT_SSH_HOSTNAME,
+            validate: (value) => {
+                if (value.trim().length === 0)
+                    return t('validation.required');
+                if (!hostnameRegex.test(value))
+                    return t('validation.invalidFormat');
+                return true;
+            },
+        },
+        {
+            type: 'number',
+            name: 'port',
+            message: t('ssh.port'),
+            initial: KNOWN_SSH_PORT,
+            min: 1,
+            max: 65535,
+        },
+    ];
+    if (rutoken === undefined)
+        questions.push({
+            type: 'toggle',
+            name: 'rutoken',
+            message: t('ssh.rutoken'),
+            initial: false,
+            active: t('yes'),
+            inactive: t('no'),
+        });
+    logger.step(t('connection.caption'));
+    const response = await prompts(questions);
+    return createConnectionString({
+        username: response.username,
+        hostname: response.hostname,
+        port: response.port,
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        rutoken: rutoken || response.rutoken,
+    });
+}
+
+/**
+ * Режим `stdio`: ввод игнорируется, `stdout` и `stderr` перехватываются.
+ *
+ * Используется для полного захвата вывода команды.
+ *
+ * @since 0.4.0
+ *
+ **/
+const STDIO_CAPTURE_OUTPUT = ['ignore', 'pipe', 'pipe'];
+/**
+ * Ошибка выполнения команды в shell.
+ *
+ * Возникает, когда команда завершилась с кодом, не входящим в `doneCodes` или `cancelCodes`.
+ *
+ * @since 0.4.0
+ *
+ **/
+class ShellError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ShellError';
+        Error.captureStackTrace(this, ShellError);
+    }
+}
+/**
+ * Асинхронно выполняет команду и возвращает результат.
+ *
+ * Перехватывает `stdout` и `stderr`.
+ * Поддерживает кастомные коды успеха и отмены.
+ *
+ * @param command - Команда (например, `ls`, `rsync`).
+ * @param args - Аргументы команды.
+ * @param options - Опции запуска процесса.
+ * @returns Результат выполнения: код, вывод, ошибки.
+ * @throws {ShellError} Если команда завершилась с ошибкой.
+ * @throws {OperationCanceledError} Если операция была отменена пользователем.
+ *
+ * @since 0.4.0
+ *
+ **/
+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}`));
+            }
+        });
+    });
+}
+/**
+ * Универсальная функция для запуска команд.
+ *
+ * @since 0.4.0
+ *
+ **/
+const runCommandAsync = async (command, args, options = {}) => await execAsync(command, args, { ...options });
+
+function getCurrentPackageManager() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (!userAgent)
+        return;
+    const [name, version] = userAgent.split(' ')[0].split('/');
+    return {
+        name,
+        version,
+    };
+}
+function toAnswers(...managers) {
+    return managers.map(manager => ({
+        title: t('dependencies.answer.yesUsing', { manager }),
+        value: manager,
+    }));
+}
+async function promptInstallDependenciesAsync(cwd) {
+    const currentManager = getCurrentPackageManager();
+    const { manager } = await prompts({
+        type: 'select',
+        name: 'manager',
+        message: t('dependencies.prompt'),
+        hint: `(${t('hint.recommended').toLowerCase()})`,
+        choices: currentManager
+            ? [
+                {
+                    title: t('dependencies.answer.yesUsing', { manager: currentManager.name }),
+                    value: currentManager.name,
+                },
+                {
+                    title: t('dependencies.answer.no'),
+                    value: '',
+                },
+            ]
+            : [
+                ...toAnswers('pnpm', 'yarn', 'npm', 'bun'),
+                {
+                    title: t('dependencies.answer.no'),
+                    value: '',
+                },
+            ],
+    });
+    if (!manager)
+        return;
+    await runCommandAsync(manager, ['install'], { cwd, shell: true });
+}
+
+const DEFAULT_BRANCH = 'main';
+async function resolveGithubInfoAsync(input) {
+    let owner;
+    let repository;
+    let branch;
+    logger.step(t('github.caption'));
+    const answer = await prompts([
+        {
+            type: 'text',
+            name: 'owner',
+            message: t('github.owner.prompt'),
+            initial: owner,
+            validate: (value) => {
+                if (value.trim().length === 0)
+                    return t('validation.required');
+                else
+                    return true;
+            },
+        },
+        {
+            type: 'text',
+            name: 'repository',
+            message: t('github.repository.prompt'),
+            initial: repository,
+            validate: (value) => {
+                if (value.trim().length === 0)
+                    return t('validation.required');
+                else
+                    return true;
+            },
+        },
+        {
+            type: 'text',
+            name: 'branch',
+            message: t('github.branch.prompt'),
+            initial: branch || DEFAULT_BRANCH,
+        },
+    ]);
+    owner = answer.owner.trim();
+    repository = answer.repository.trim();
+    branch = answer.branch?.trim();
+    return {
+        owner,
+        repository,
+        branch: branch || DEFAULT_BRANCH,
+    };
+}
+
+export { DEFAULT_SSH_USERNAME as D, resolveGithubInfoAsync as a, resolveConnectionStringAsync as b, renderDirectoryAsync as c, DEFAULT_SSH_HOSTNAME as d, promptInstallDependenciesAsync as p, resolveFeaturesAsync as r, toTemplateData as t };