spectrum-cli 1.1.1 → 1.2.0

package/src/release.js

@@ -1,81 +1,128 @@
 #!/usr/bin/env node
 const { goToDevBranch, goToMainBranch, updateCurrentBranch } = require('./git');
 const { changelogChangeHeader, changelogRemoveEmptyChapters, changelogAddUnreleasedBlock, changelogCommit } = require('./changelog');
-const { getVersion, logSuccess, logError, execCommand, getCurrentBranch, getMainBranch, colors } = require('./utils');
+const path = require('path');
+const { getVersion, logSuccess, logError, execCommand, getCurrentBranch, getMainBranch, getMergeRequestUrl } = require('./utils');
+const { runCommand } = require('./command-executor');
+const {
+    requireGitRepo,
+    requireCleanWorkingTree,
+    requireCurrentBranchUpToDateWithRemote,
+    requireMainAndDevBranches,
+    requireOnReleaseBranch,
+    requireReleaseBranchMissing,
+    requirePackageVersion,
+    requireFileExists,
+    requireChangelogFormatted
+} = require('./preflight');
 
 function releaseCreate() {
-    goToDevBranch();
-    updateCurrentBranch();
-    
+    if (!goToDevBranch()) return false;
+    if (!updateCurrentBranch()) return false;
+
     const currentVersion = getVersion();
     if (!currentVersion) {
-        logError('❌', 'Cannot get version from package.json');
+        logError('❌', 'Не удалось получить версию из package.json');
         return false;
     }
-    
-    if (execCommand(`git switch -c release/${currentVersion}`, null, null)) {
-        logSuccess('🌱', `Create new release branch ${getCurrentBranch()}.`);
-        return true;
+
+    if (!execCommand(`git switch -c release/${currentVersion}`)) {
+        return false;
     }
-    
-    return false;
+
+    logSuccess('🌱', 'Создана новая release-ветка %s.', getCurrentBranch());
+    return true;
 }
 
 function releasePush() {
     const currentBranch = getCurrentBranch();
-    
-    if (execCommand(`git push origin ${currentBranch}`, null, null)) {
-        logSuccess('📤', `Push release branch ${currentBranch}.`);
-        logSuccess('🌐', 'Go to https://gitlab.spectrumdata.tech/ and merge branch manually.');
-        goToMainBranch();
-        return true;
+    if (!execCommand(`git push origin ${currentBranch}`)) {
+        return false;
     }
-    
-    return false;
-}
 
-function releaseClose() {
-    const mainBranch = getMainBranch();
-    
-    goToMainBranch();
-    updateCurrentBranch();
-    
-    goToDevBranch();
-    updateCurrentBranch();
-    
-    if (execCommand(`git merge ${mainBranch}`, null, null)) {
-        logSuccess('🔀', `Merge branch ${getCurrentBranch()} with ${mainBranch}.`);
-        
-        if (execCommand(`git push origin ${getCurrentBranch()} -o ci.skip`, null, null)) {
-            logSuccess('📤', `Push branch ${getCurrentBranch()}.`);
-            return true;
-        }
+    logSuccess('📤', 'Release-ветка %s отправлена.', currentBranch);
+    const mrUrl = getMergeRequestUrl(currentBranch, getMainBranch());
+    if (mrUrl) {
+        logSuccess('🌐', 'Создать Merge Request: %s', mrUrl);
     }
-    
-    return false;
+    return goToMainBranch();
 }
 
-function releaseStart() {
-    const steps = [
-        { name: 'Create release branch', fn: releaseCreate },
-        { name: 'Change header', fn: changelogChangeHeader },
-        { name: 'Remove empty chapters', fn: changelogRemoveEmptyChapters },
-        { name: 'Add unreleased block', fn: changelogAddUnreleasedBlock },
-        { name: 'Commit changelog', fn: changelogCommit },
-        { name: 'Push release', fn: releasePush }
-    ];
-    
-    for (const step of steps) {
-        if (!step.fn()) {
-            logError('✖', `Failed at step: ${step.name}`);
-            return false;
-        }
+function releaseCheckChangelogLint() {
+    const result = requireChangelogFormatted();
+    if (!result.ok) {
+        logError('❌', result.reason || 'Файл CHANGELOG.md не прошел линтинг.');
+        return false;
     }
-    
-    logSuccess('🚀', 'Release started successfully!');
     return true;
 }
 
+function releaseClose() {
+    return runCommand({
+        name: 'release close',
+        checks: [
+            { name: 'git-repo', run: requireGitRepo },
+            { name: 'clean-working-tree', run: requireCleanWorkingTree },
+            { name: 'branch-up-to-date', run: requireCurrentBranchUpToDateWithRemote },
+            { name: 'on-release-branch', run: requireOnReleaseBranch },
+            { name: 'main-and-dev-branches', run: requireMainAndDevBranches }
+        ],
+        steps: [
+            { name: 'switch-main', run: () => goToMainBranch() },
+            { name: 'update-main', run: () => updateCurrentBranch() },
+            { name: 'switch-dev', run: () => goToDevBranch() },
+            { name: 'update-dev', run: () => updateCurrentBranch() },
+            {
+                name: 'merge-main-into-dev',
+                run: () => {
+                    const mainBranch = getMainBranch();
+                    if (!execCommand(`git merge ${mainBranch}`)) {
+                        return false;
+                    }
+                    logSuccess('🔀', 'Ветка %s смержена с %s.', getCurrentBranch(), mainBranch);
+                    return true;
+                }
+            },
+            {
+                name: 'push-dev',
+                run: () => {
+                    const currentBranch = getCurrentBranch();
+                    if (!execCommand(`git push origin ${currentBranch} -o ci.skip`)) {
+                        return false;
+                    }
+                    logSuccess('📤', 'Ветка %s отправлена.', currentBranch);
+                    return true;
+                }
+            }
+        ]
+    });
+}
+
+function releaseStart() {
+    return runCommand({
+        name: 'release start',
+        checks: [
+            { name: 'git-repo', run: requireGitRepo },
+            { name: 'clean-working-tree', run: requireCleanWorkingTree },
+            { name: 'branch-up-to-date', run: requireCurrentBranchUpToDateWithRemote },
+            { name: 'main-and-dev-branches', run: requireMainAndDevBranches },
+            { name: 'package-version', run: requirePackageVersion },
+            { name: 'changelog-exists', run: () => requireFileExists('CHANGELOG.md') },
+            { name: 'unreleased-template-exists', run: () => requireFileExists(path.join(__dirname, 'UNRELEASED.md')) },
+            { name: 'changelog-prettier-check', run: requireChangelogFormatted },
+            { name: 'release-branch-missing', run: (ctx) => requireReleaseBranchMissing(`release/${ctx.version}`) }
+        ],
+        steps: [
+            { name: 'change-header', run: changelogChangeHeader },
+            { name: 'remove-empty-chapters', run: changelogRemoveEmptyChapters },
+            { name: 'add-unreleased-block', run: changelogAddUnreleasedBlock },
+            { name: 'lint-changelog', run: releaseCheckChangelogLint },
+            { name: 'create-release-branch', run: releaseCreate },
+            { name: 'commit-changelog', run: changelogCommit },
+            { name: 'push-release', run: releasePush }
+        ]
+    });
+}
 
 module.exports = {
     releaseCreate,

package/src/utils.js

@@ -14,12 +14,29 @@ function log(emoji, message, color = colors.green) {
     console.log(` ${emoji} ${message}`);
 }
 
-function logSuccess(emoji, message) {
-    log(emoji, `${colors.green}${message}${colors.reset}`);
+function formatLogMessage(template, args, color) {
+    if (!args || args.length === 0) {
+        return template;
+    }
+
+    let argIndex = 0;
+    return template.replace(/%s/g, () => {
+        if (argIndex >= args.length) {
+            return '%s';
+        }
+
+        const value = args[argIndex];
+        argIndex += 1;
+        return `${color}${String(value)}${colors.reset}`;
+    });
 }
 
-function logError(emoji, message) {
-    log(emoji, `${colors.red}${message}${colors.reset}`);
+function logSuccess(emoji, message, ...args) {
+    log(emoji, formatLogMessage(message, args, colors.green));
+}
+
+function logError(emoji, message, ...args) {
+    log(emoji, formatLogMessage(message, args, colors.red));
 }
 
 function execSilent(command) {
@@ -30,14 +47,11 @@ function execSilent(command) {
     }
 }
 
-function execCommand(command, successMessage, errorMessage) {
+function execCommand(command) {
     try {
         execSync(command, { stdio: 'pipe' });
         return true;
     } catch (error) {
-        if (errorMessage) {
-            console.error(errorMessage);
-        }
         return false;
     }
 }
@@ -78,6 +92,28 @@ function getVersion() {
     }
 }
 
+function getRemoteUrl() {
+    const raw = execSilent('git remote get-url origin');
+    if (!raw) return null;
+
+    const sshMatch = raw.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+    if (sshMatch) return `https://${sshMatch[1]}/${sshMatch[2]}`;
+
+    const httpsMatch = raw.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?$/);
+    if (httpsMatch) return `https://${httpsMatch[1]}/${httpsMatch[2]}`;
+
+    return null;
+}
+
+function getMergeRequestUrl(sourceBranch, targetBranch) {
+    const baseUrl = getRemoteUrl();
+    if (!baseUrl) return null;
+
+    const source = encodeURIComponent(sourceBranch);
+    const target = encodeURIComponent(targetBranch);
+    return `${baseUrl}/-/merge_requests/new?merge_request[source_branch]=${source}&merge_request[target_branch]=${target}`;
+}
+
 module.exports = {
     colors,
     log,
@@ -89,5 +125,7 @@ module.exports = {
     getMainBranch,
     getDevelopBranch,
     getPackageManager,
-    getVersion
+    getVersion,
+    getRemoteUrl,
+    getMergeRequestUrl
 };

package/src/version.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 const fs = require('fs');
-const { execCommand, logSuccess, logError, colors } = require('./utils');
+const { logSuccess, logError } = require('./utils');
+const { runCommand } = require('./command-executor');
+const { requireGitRepo, requireCleanWorkingTree, requireFileExists, requirePackageVersion } = require('./preflight');
 
 function upVersion(oldVersion, upType) {
     const [major, minor, patch] = oldVersion.split('.').map(Number);
@@ -16,35 +18,39 @@ function upVersion(oldVersion, upType) {
     }
 }
 
-function getVersionTypescript() {
-    try {
-        const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
-        return packageJson.version;
-    } catch (error) {
-        return null;
-    }
-}
-
-function setVersionTypescript(versionType) {
+function updateVersionFile(versionType) {
     try {
         const packageJson = JSON.parse(fs.readFileSync('package.json', 'utf8'));
         const oldVersion = packageJson.version;
         const newVersion = upVersion(oldVersion, versionType);
-        
+
         packageJson.version = newVersion;
         fs.writeFileSync('package.json', JSON.stringify(packageJson, null, 2) + '\n');
-        
-        logSuccess('🔖', `Current version ${oldVersion} up to ${colors.green}${newVersion}${colors.reset}.`);
+        logSuccess('🔖', 'Версия обновлена с %s до %s.', oldVersion, newVersion);
         return true;
     } catch (error) {
-        logError('❌', 'Error updating version in package.json');
+        logError('❌', 'Ошибка при обновлении версии в package.json');
         return false;
     }
 }
 
+function setVersion(versionType) {
+    return runCommand({
+        name: `version up ${versionType}`,
+        checks: [
+            { name: 'git-repo', run: requireGitRepo },
+            { name: 'package-json-exists', run: () => requireFileExists('package.json') },
+            { name: 'package-version', run: requirePackageVersion },
+            { name: 'clean-working-tree', run: requireCleanWorkingTree }
+        ],
+        steps: [
+            { name: 'update-package-version', run: () => updateVersionFile(versionType) }
+        ]
+    });
+}
+
 
 module.exports = {
     upVersion,
-    getVersionTypescript,
-    setVersionTypescript
+    setVersion
 };