@mirta/cli 0.3.4 → 0.4.0

package/dist/package.mjs

@@ -1,156 +1,68 @@
+import nodePath, { posix } from 'node:path';
+import pMap from 'p-map';
+import { writeFile, glob } from 'node:fs/promises';
+import { resolveMonorepoContextAsync } from '@mirta/workspace';
+import { readPackageAsync, PackageError, resolvePackagePath, toPosix } from '@mirta/package';
+import { T as THIS_PACKAGE_NAME } from './constants.mjs';
+import { l as logger, r as runCommandAsync, t } from './index.mjs';
 import chalk from 'chalk';
-import { a as getLocale, g as getLocalized, u as useLogger, r as runCommandAsync } from './shell.mjs';
-import nodePath from 'node:path';
-import { readdirSync, statSync, readFileSync, existsSync, writeFileSync } from 'node:fs';
-
-const { dim, yellow: yellow$1 } = chalk;
-const locale = getLocale();
-const helpMessageEn = `\
-Performs operations over monorepo projects powered by the Mirta Framework.
-
-${yellow$1('Usage:')}
-  mirta [command] [options...]
-
-${yellow$1('Commands:')}
-- release:
-  ${dim('Increase package versions following semantic versioning rules.')}
-- publish:
-  ${dim('Builds and publishes packages to npm registry.')}
-
-${yellow$1(`Options for 'release':`)}
-  --dry
-    ${dim('Runs the command in dry run mode, showing what would be done but not performing any actual changes. Useful for previewing changes before applying them.')}
-  --preid <custom-pre-release-id>
-    ${dim('Sets a custom pre-release identifier that will be appended to the version string (for example, beta.1). This option allows creating pre-release versions like alpha, beta, rc etc., prior to official stable releases.')}
-  --skipPrompts
-    ${dim('Skips user interaction prompts entirely. The command runs non-interactively, automatically proceeding with defaults or configured values where applicable.')}
-  --skipGit
-    ${dim('Omits Git-related actions such as committing changes, tagging commits, or pushing updates to remote repositories. This can be useful if you want to manually manage Git operations later.')}
-
-${yellow$1(`Options for 'publish':`)}
-  --dry
-    ${dim('Runs the command in dry run mode, showing what would be done but not performing any actual changes. Useful for previewing changes before applying them.')}
-  --skipBuild
-    ${dim('Excludes running the build process after version bumps. Bypasses execution of tasks defined in the build pipeline, allowing users to control whether they need a rebuild after updating package versions.')}
-  --skipGit
-    ${dim('Omits Git-related actions such as committing changes, tagging commits, or pushing updates to remote repositories. This can be useful if you want to manually manage Git operations later.')}
-    
-`;
-const helpMessageRu = `\
-Выполняет операции над проектами монорепозитория, работающими на базе фреймворка Mirta.
-
-${yellow$1('Использование:')}
-  mirta [command] [options...]
-
-${yellow$1('Команды:')}
-- release:
-  ${dim('Повышение версий пакетов согласно правилам семантического версионирования.')}
-- publish:
-  ${dim('Сборка и публикация пакетов в реестр npm.')}
-
-${yellow$1(`Опции для 'release':`)}
-  --dry
-    ${dim('Запускает команду в режиме симуляции ("dry run"), показывая изменения, которые будут произведены, но фактически ничего не меняя. Полезно для предварительного просмотра изменений перед применением.')}
-  --preid <custom-pre-release-id>
-    ${dim('Устанавливает кастомный префикс для предварительной версии, который добавляется к номеру версии пакета (например, beta.1). Эта опция позволяет создавать предварительные версии типа альфа, бета, RC и др. перед официальным стабильным выпуском.')}
-  --skipPrompts
-    ${dim('Пропускает интерактивные запросы пользователя. Команда выполняется автоматически, используя значения по умолчанию или заданные настройки.')}
-  --skipGit
-    ${dim('Игнорирует действия, связанные с системой контроля версий Git, такие как фиксация изменений, создание меток коммитов или отправка изменений на удалённый репозиторий. Может пригодиться, если вы хотите самостоятельно управлять операциями с Git позже.')}
-
-${yellow$1(`Опции для 'publish':`)}
-  --dry
-    ${dim('Запускает команду в режиме симуляции ("dry run"), показывая изменения, которые будут произведены, но фактически ничего не меняя. Полезно для предварительного просмотра изменений перед применением.')}
-  --skipBuild
-    ${dim('Исключает запуск процесса сборки после обновления версий пакетов. Пропускает выполнение заданий, указанных в конвейере сборки, позволяя вам самим решать, необходима ли повторная компиляция после изменения номеров версий.')}
-  --skipGit
-    ${dim('Игнорирует действия, связанные с системой контроля версий Git, такие как фиксация изменений, создание меток коммитов или отправка изменений на удалённый репозиторий. Может пригодиться, если вы хотите самостоятельно управлять операциями с Git позже.')}
-`;
-const helpMessage = locale === 'ru-RU'
-    ? helpMessageRu
-    : helpMessageEn;
 
 const { yellow } = chalk;
-const messages = await getLocalized();
-const logger = useLogger(messages);
-const rootDir = process.cwd();
-const packagesDir = nodePath.join(rootDir, 'packages');
-const getPackageRoot = (packageName) => nodePath.join(packagesDir, packageName);
-// Перечисляем пакеты, которые должны выйти в релиз.
-const packages = readdirSync(packagesDir)
-    .filter((pkgName) => {
-    const pkgRoot = getPackageRoot(pkgName);
-    if (!statSync(pkgRoot).isDirectory())
-        return;
-    const pkg = JSON.parse(readFileSync(nodePath.join(pkgRoot, 'package.json'), 'utf-8'));
-    return !pkg.private;
-});
-const templatePackages = {};
-/** Имя пользователя или организации, владеющей пакетом. */
-let scope;
-/** Форматированный scope пакета. */
-let scoped;
-/** Использовать scope в качестве префикса в названиях пакетов. */
-let scopeAsPackagePrefix = false;
-const mirtaConfigFilePath = nodePath.join(rootDir, 'mirta.config.json');
-const rootPackage = JSON.parse(readFileSync(nodePath.join(rootDir, 'package.json'), 'utf-8'));
-if (rootPackage.name) {
-    const match = /^@([^/]+)\//i.exec(rootPackage.name);
-    if (match?.[1]) {
-        scope = match[1];
-        scoped = `@${match[1]}/`;
-    }
+const MAX_CONCURRENT_WRITES = 5;
+const MAX_CONCURRENT_REQUESTS = 5;
+const cwd = process.cwd();
+const context = await resolveMonorepoContextAsync(cwd);
+const rootDir = context.rootDir;
+// Список всех пакетов репозитория.
+const packages = {};
+for (const pkg of context.packages) {
+    // Необходимость обновления версии определяется
+    // наличием атрибута версии.
+    //
+    // Не зависит от статуса private пакета.
+    //
+    if (pkg.version)
+        packages[pkg.name] = {
+            workspacePath: pkg.workspacePath,
+            isPrivate: pkg.isPrivate,
+        };
 }
+const rootPackage = await readPackageAsync(rootDir);
 /** Возвращает текущую версию корневого проекта. */
 function getCurrentVersion() {
+    if (!rootPackage.version)
+        throw PackageError.getScoped(THIS_PACKAGE_NAME, 'noVersionField');
     return rootPackage.version;
 }
 function hasScript(name) {
     return rootPackage.scripts?.[name] !== void 0;
 }
-if (existsSync(mirtaConfigFilePath)) {
-    const config = JSON.parse(readFileSync(mirtaConfigFilePath, 'utf-8'));
-    if (config.scope) {
-        scope = config.scope;
-        if (scope.startsWith('@'))
-            scope = scope.slice(1);
-        if (scope)
-            scoped = `@${scope}/`;
+async function resolveTemplatePathsAsync(config) {
+    const templates = config.project?.templates;
+    if (!Array.isArray(templates))
+        return [];
+    const pathPatterns = [];
+    for (const templatePath of templates) {
+        const resolvedDir = toPosix(nodePath.resolve(rootDir, templatePath));
+        if (!resolvedDir.startsWith(rootDir + posix.sep)) {
+            logger.warn(t('package.templateOutsideRoot', { template: templatePath }));
+            continue;
+        }
+        pathPatterns.push(posix.join(templatePath, '**', 'package.json'));
     }
-    scopeAsPackagePrefix = config.scopeAsPackagePrefix === true;
-    if (config.templates && Array.isArray(config.templates)) {
-        config.templates.forEach((template) => {
-            const templatesDir = nodePath.resolve(rootDir, template);
-            // Предохранитель от выхода за пределы рабочей директории.
-            if (!templatesDir.startsWith(rootDir))
-                return;
-            // Обрабатываем только существующие директории.
-            if (!statSync(templatesDir).isDirectory())
-                return;
-            const localTemplatePackages = readdirSync(templatesDir, {
-                withFileTypes: true,
-                recursive: true,
-            })
-                .reduce((items, nextEntry) => {
-                if (nextEntry.name === 'package.json')
-                    items.push(nextEntry.parentPath);
-                return items;
-            }, []);
-            templatePackages[templatesDir] = localTemplatePackages;
-        });
+    const realPaths = new Set();
+    if (pathPatterns.length === 0)
+        return [];
+    for await (const pkgPath of glob(pathPatterns, {
+        cwd: rootDir,
+        exclude: ['node_modules/**', 'dist/**'],
+    })) {
+        realPaths.add(toPosix(pkgPath));
     }
+    return [...realPaths];
 }
 const isWorkspacePackage = (pkgName) => {
-    if (!pkgName)
-        return false;
-    if (packages.includes(pkgName))
-        return true;
-    if (!scoped || !pkgName.startsWith(scoped))
-        return false;
-    pkgName = pkgName.slice(scoped.length);
-    if (scopeAsPackagePrefix)
-        pkgName = `${scope}-${pkgName}`;
-    return packages.includes(pkgName);
+    return Boolean(pkgName && packages[pkgName]);
 };
 function updateDependencies(pkg, depType, version) {
     const deps = pkg[depType];
@@ -163,39 +75,35 @@ function updateDependencies(pkg, depType, version) {
         logger.step(`- ${dep}`);
     });
 }
-function updateTemplateDependencies(templateRoot, version) {
-    logger.step(`Template: ${nodePath.relative(rootDir, templateRoot)}`);
-    const pkgPath = nodePath.join(templateRoot, 'package.json');
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+async function updateTemplateDependencies(pkgPath, version) {
+    logger.step(pkgPath);
+    const pkg = await readPackageAsync(pkgPath);
     updateDependencies(pkg, 'dependencies', version);
     updateDependencies(pkg, 'devDependencies', version);
-    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
 }
-function updatePackageVersion(pkgRoot, version) {
-    const pkgPath = nodePath.join(pkgRoot, 'package.json');
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+async function updatePackageVersion(pkgRoot, version) {
+    const pkgPath = resolvePackagePath(pkgRoot);
+    const pkg = await readPackageAsync(pkgPath);
     logger.step(pkgRoot === rootDir
-        ? 'Root package'
-        : `Package: ${pkg.name ?? nodePath.basename(pkgRoot)}`);
+        ? '- <root>'
+        : `- ${pkg.name ?? nodePath.basename(pkgRoot)}`);
     pkg.version = version;
-    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
 }
-function updateVersion(version) {
+async function updateVersion(version, config) {
     logger.log(`Patching all packages to version ${version}`);
-    // Update root package.json
-    updatePackageVersion(rootDir, version);
-    // Update all packages
-    packages.forEach((pkgDirName) => {
-        updatePackageVersion(nodePath.join(packagesDir, pkgDirName), version);
-    });
-    const templateKeys = Object.keys(templatePackages);
-    if (templateKeys.length > 0) {
+    // Обновляет корневой пакет.
+    await updatePackageVersion(rootDir, version);
+    rootPackage.version = version;
+    // Обновляет все остальные пакеты репозитория.
+    await pMap(Object.values(packages), ({ workspacePath }) => updatePackageVersion(nodePath.join(rootDir, workspacePath), version), { concurrency: MAX_CONCURRENT_WRITES });
+    // Повторное сканирование FS на каждое обновление - для безопасности.
+    const templatePaths = await resolveTemplatePathsAsync(config);
+    // Обновляет пакеты, используемые в шаблонах.
+    if (templatePaths.length > 0) {
         logger.log(`Patching template packages`);
-        Object.keys(templatePackages).forEach((templatesDir) => {
-            templatePackages[templatesDir].forEach((templateRoot) => {
-                updateTemplateDependencies(templateRoot, version);
-            });
-        });
+        await pMap(templatePaths, path => updateTemplateDependencies(path, version), { concurrency: MAX_CONCURRENT_WRITES });
     }
 }
 /** Выполняет сборку пакетов стандартной командой `pnpm run build`. */
@@ -208,7 +116,31 @@ async function buildPackagesAsync(skipBuild) {
         logger.log(`${yellow('Skip')} building packages`);
     }
 }
-async function publishSinglePackageAsync(pkgName, version, flags) {
+/**
+ * Проверяет существование пакета в NPM.
+ *
+ * @since 0.4.0
+ *
+ * @internal
+ *
+ **/
+async function checkPackageExistsAsync(pkgName) {
+    try {
+        await runCommandAsync('npm', ['view', pkgName, 'version'], {
+            stdio: 'pipe',
+        });
+        return true;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            const message = e.message;
+            if (message.includes('404'))
+                return false;
+        }
+        throw e;
+    }
+}
+async function publishSinglePackageAsync(pkgName, pkgPath, version, flags) {
     let releaseTag = void 0;
     if (version.includes('alpha')) {
         releaseTag = 'alpha';
@@ -219,7 +151,7 @@ async function publishSinglePackageAsync(pkgName, version, flags) {
     else if (version.includes('rc')) {
         releaseTag = 'rc';
     }
-    logger.step(`Publishing ${pkgName}`);
+    logger.step(t('publish.packagePublishing', { name: pkgName }));
     try {
         await runCommandAsync('pnpm', [
             'publish',
@@ -228,14 +160,14 @@ async function publishSinglePackageAsync(pkgName, version, flags) {
             'public',
             ...(flags),
         ], {
-            cwd: getPackageRoot(pkgName),
+            cwd: pkgPath,
             stdio: 'pipe',
         });
-        logger.success(`Published ${pkgName}@${version}`);
+        logger.success(t('publish.packagePublished', { name: `${pkgName}@${version}` }));
     }
     catch (e) {
         if (e instanceof Error && /previously published/.exec(e.message)) {
-            logger.warn(`Skipping already published ${pkgName}`);
+            logger.warn(t('publish.skippingPublished', { name: pkgName }));
         }
         else {
             throw e;
@@ -244,7 +176,25 @@ async function publishSinglePackageAsync(pkgName, version, flags) {
 }
 /** Выполняет публикацию пакетов монорепозитория в NPM. */
 async function publishPackagesAsync(version, skipGitChecks, isDryRun) {
-    logger.log('Publishing packages...');
+    logger.log(t('publish.begin'));
+    const packagesToPublish = Object.entries(packages)
+        .filter(([, pkg]) => !pkg.isPrivate);
+    if (!isDryRun) {
+        const existenceChecks = await pMap(packagesToPublish, async ([pkgName]) => ({
+            name: pkgName,
+            isExists: await checkPackageExistsAsync(pkgName),
+        }), { concurrency: MAX_CONCURRENT_REQUESTS, stopOnError: true });
+        const unpublishedPackages = existenceChecks
+            .filter(({ isExists }) => !isExists)
+            .map(({ name }) => name);
+        if (unpublishedPackages.length > 0) {
+            logger.error(t('publish.newPackages', {
+                packages: unpublishedPackages.join(', '),
+            }));
+            logger.error(t('publish.initialPublishRequired'));
+            throw new Error('Packages not found in NPM registry');
+        }
+    }
     const flags = [];
     if (isDryRun)
         flags.push('--dry-run');
@@ -252,8 +202,14 @@ async function publishPackagesAsync(version, skipGitChecks, isDryRun) {
         flags.push('--no-git-checks');
     if (process.env.CI)
         flags.push('--provenance');
-    for (const pkgName of packages)
-        await publishSinglePackageAsync(pkgName, version, flags);
+    for (const [pkgName, pkg] of packagesToPublish) {
+        // Приватные пакеты не публикуются.
+        if (pkg.isPrivate) {
+            logger.step(t('publish.skippingPrivate', { name: pkgName }));
+            continue;
+        }
+        await publishSinglePackageAsync(pkgName, posix.join(rootDir, pkg.workspacePath), version, flags);
+    }
 }
 
-export { hasScript as a, buildPackagesAsync as b, getCurrentVersion as g, helpMessage as h, publishPackagesAsync as p, updateVersion as u };
+export { buildPackagesAsync as b, getCurrentVersion as g, hasScript as h, publishPackagesAsync as p, updateVersion as u };

package/dist/publish.mjs

@@ -1,54 +1,74 @@
-import { parseArgs } from 'node:util';
-import { g as getCurrentVersion, h as helpMessage, b as buildPackagesAsync, p as publishPackagesAsync } from './package.mjs';
-import cliPackage from '../package.json' with { type: 'json' };
+import { g as getCurrentVersion, b as buildPackagesAsync, p as publishPackagesAsync } from './package.mjs';
+import { a as assertNoParseErrors, l as logger } from './index.mjs';
+import 'node:path';
+import 'p-map';
+import 'node:fs/promises';
+import '@mirta/workspace';
+import '@mirta/package';
+import './constants.mjs';
 import 'chalk';
-import './shell.mjs';
+import 'prompts';
+import '@mirta/staged-args';
 import 'node:child_process';
-import 'node:url';
-import 'node:fs';
-import 'node:path';
-import 'lodash.merge';
+import '@mirta/i18n';
+import '../package.json' with { type: 'json' };
+import '@mirta/basics/fuzzy';
 
-const currentVersion = getCurrentVersion();
-const allOptions = ({
-    dry: {
+const options = ({
+    'dry-run': {
         type: 'boolean',
-        default: false,
     },
-    skipGit: {
+    'skip-git': {
         type: 'boolean',
-        default: false,
     },
-    skipBuild: {
+    'skip-build': {
         type: 'boolean',
-        default: false,
     },
-    help: {
+    // Deprecated. Use 'dry-run' instead
+    'dry': {
         type: 'boolean',
-        short: 'h',
-        default: false,
     },
-    version: {
+    // Deprecated. Use 'skip-git' instead
+    'skipGit': {
+        type: 'boolean',
+    },
+    // Deprecated. Use 'skip-build' instead
+    'skipBuild': {
         type: 'boolean',
-        short: 'v',
-        default: false,
     },
 });
-const args = process.argv.slice(2);
-const { values: argv } = parseArgs({
-    args,
-    options: allOptions,
-    allowPositionals: true,
-});
-if (argv.help) {
-    console.log(helpMessage);
-    process.exit(0);
+function parseArgs(args) {
+    const parseResult = args.parseFinal(options);
+    assertNoParseErrors(parseResult);
+    const { values, positionals } = parseResult.data;
+    if (values.dry) {
+        logger.warn('Deprecated flag "--dry" used. Please use "--dry-run" instead');
+        values['dry-run'] = values['dry-run'] !== false;
+    }
+    if (values.skipGit) {
+        logger.warn('Deprecated flag "--skipGit" used. Please use "--skip-git" instead');
+        values['skip-git'] = values['skip-git'] !== false;
+    }
+    if (values.skipBuild) {
+        logger.warn('Deprecated flag "--skipBuild" used. Please use "--skip-build" instead');
+        values['skip-build'] = values['skip-build'] !== false;
+    }
+    return {
+        values,
+        positionals,
+    };
 }
-if (argv.version) {
-    console.log(`${cliPackage.name} v${cliPackage.version}`);
-    process.exit(0);
+
+async function runAsync(args) {
+    // === 1. Парсинг аргументов ===
+    const { values: argv } = parseArgs(args);
+    const isDryRun = argv['dry-run'] ?? false;
+    const skipGit = argv['skip-git'] ?? false;
+    const skipBuild = argv['skip-build'] ?? false;
+    // === 2. Выполнение сборки и публикации ===
+    const currentVersion = getCurrentVersion();
+    await buildPackagesAsync(skipBuild);
+    await publishPackagesAsync(currentVersion, skipGit, isDryRun);
 }
-const skipGit = argv.skipGit;
-const isDryRun = argv.dry;
-await buildPackagesAsync(argv.skipBuild);
-await publishPackagesAsync(currentVersion, skipGit, isDryRun);
+
+export { runAsync };