spectrum-cli 2.1.2 → 3.0.0

package/src/changelog.js

@@ -2,114 +2,20 @@
 const fs = require('fs');
 const path = require('path');
 const readline = require('readline');
-const { logSuccess, logError, execCommand, execSilent, getVersion, getCurrentBranch, colors } = require('./utils');
+const { logSuccess, logError, execSilent, getCurrentBranch, colors } = require('./utils');
 const { runCommand } = require('./command-executor');
-const { requireGitRepo, requireFileExists, requirePrettierAvailable, requireChangelogFormatted } = require('./preflight');
-
-function getPrettierRunner() {
-    const npxVersion = execSilent('npx --yes prettier --version');
-    if (npxVersion) return 'npx --yes prettier';
-    const directVersion = execSilent('prettier --version');
-    if (directVersion) return 'prettier';
-    return null;
-}
-
-function ensurePrettierAvailable() {
-    const runner = getPrettierRunner();
-    if (!runner) {
-        logError('❌', 'Prettier недоступен. Установите его или используйте npx.');
-        return null;
-    }
-    return runner;
-}
-
-function checkChangelogWithPrettier() {
-    const runner = ensurePrettierAvailable();
-    if (!runner) return false;
-    const ok = execCommand(`${runner} --check CHANGELOG.md`);
-    if (!ok) {
-        logError('❌', 'Файл CHANGELOG.md не прошел проверку Prettier. Исправьте форматирование перед продолжением.');
-        return false;
-    }
-    return true;
-}
-
-function changelogChangeHeader() {
-    try {
-        if (!checkChangelogWithPrettier()) {
-            return false;
-        }
-        const currentVersion = getVersion();
-        if (!currentVersion) {
-            return false;
-        }
-
-        const changelog = fs.readFileSync('CHANGELOG.md', 'utf8');
-        const updatedChangelog = changelog.replace(
-            /## \[Unreleased\]/g,
-            `## 🚀 [${currentVersion}]`
-        );
-
-        fs.writeFileSync('CHANGELOG.md', updatedChangelog);
-        logSuccess('🔄', 'Заголовок обновлен до 🚀 [%s].', currentVersion);
-        return true;
-    } catch (error) {
-        return false;
-    }
-}
-
-function changelogRemoveEmptyChapters() {
-    try {
-        if (!checkChangelogWithPrettier()) {
-            return false;
-        }
-        const data = fs.readFileSync('CHANGELOG.md', 'utf8');
-        const updatedData = data.replaceAll(/###.*\n\n_.*_\n\n/gm, '');
-        fs.writeFileSync('CHANGELOG.md', updatedData);
-
-        logSuccess('🧹', 'Пустые разделы удалены.');
-        return true;
-    } catch (error) {
-        return false;
-    }
-}
-
-function changelogAddUnreleasedBlock() {
-    try {
-        if (!checkChangelogWithPrettier()) {
-            return false;
-        }
-        const currentVersion = getVersion();
-        if (!currentVersion) {
-            return false;
-        }
-
-        const unreleased = fs.readFileSync(path.join(__dirname, 'UNRELEASED.md'), 'utf8') + '\n';
-
-        const changelog = fs.readFileSync('CHANGELOG.md', 'utf8');
-        const updatedChangelog = changelog.replace(
-            new RegExp(`## 🚀 \\[${currentVersion}\\]`),
-            `${unreleased}## 🚀 [${currentVersion}]`
-        );
-
-        fs.writeFileSync('CHANGELOG.md', updatedChangelog);
-        logSuccess('📋', 'Блок unreleased добавлен.');
-        return true;
-    } catch (error) {
-        return false;
-    }
-}
-
-function changelogCommit() {
-    const addSuccess = execCommand('git add CHANGELOG.md');
-    const commitSuccess = execCommand('git commit --message "📝 Обновить changelog." --no-verify');
-
-    if (addSuccess && commitSuccess) {
-        logSuccess('📝', 'Коммит с обновленным changelog создан.');
-        return true;
-    }
-    return false;
-}
+const {
+    requireGitRepo,
+    requireFileExists,
+    requireChangelogFormatted,
+    requireChangelogFragments
+} = require('./preflight');
+const {
+    CHANGELOG_FILE,
+    CHANGELOG_DIR,
+    FRAGMENT_TYPES,
+    SECTION_TO_TYPE
+} = require('./changelog-config');
 
 function createReadlineInterface() {
     return readline.createInterface({
@@ -134,32 +40,31 @@ async function extractTaskFromBranch() {
         logError('❌', 'Не удалось получить имя текущей ветки.');
         return null;
     }
-    
-    const taskMatch = currentBranch.match(/([a-zA-Z]+-[0-9]+)/);
+
+    const taskMatch = currentBranch.match(/^[a-z][a-z0-9-]*\/([A-Z]+-[0-9]+)(?:-[A-Za-z0-9][A-Za-z0-9._-]*)?$/);
     if (!taskMatch) {
-        console.log(`⚠️  ${colors.yellow}Имя ветки "${currentBranch}" не содержит номер задачи в формате [a-zA-Z]+-[0-9]+.${colors.reset}`);
-        const task = await askQuestion('📝 Введите номер задачи (например, SPEC-123): ');
-        if (!task || !task.match(/^[a-zA-Z]+-[0-9]+$/)) {
-            logError('❌', 'Неверный формат задачи. Ожидается формат: [a-zA-Z]+-[0-9]+');
-            return null;
-        }
-        return task;
+        logError(
+            '❌',
+            'Имя ветки "%s" должно соответствовать <type>/<YOUTRACK-ID> или <type>/<YOUTRACK-ID>-<slug>.',
+            currentBranch
+        );
+        return null;
     }
-    
+
     return taskMatch[1];
 }
 
 async function getGitUser() {
     let name = execSilent('git config user.name');
     let email = execSilent('git config user.email');
-    
+
     if (!name || !email) {
         console.log(`⚠️  ${colors.yellow}Имя и email пользователя git не настроены.${colors.reset}`);
-        console.log(`💡 Их можно настроить так:`);
-        console.log(`   git config user.name "Ваше Имя"`);
-        console.log(`   git config user.email "your.email@domain.com"`);
+        console.log('💡 Их можно настроить так:');
+        console.log('   git config user.name "Ваше Имя"');
+        console.log('   git config user.email "your.email@domain.com"');
         console.log('');
-        
+
         if (!name) {
             name = await askQuestion('👤 Введите ваше имя: ');
             if (!name) {
@@ -167,7 +72,7 @@ async function getGitUser() {
                 return null;
             }
         }
-        
+
         if (!email) {
             email = await askQuestion('📧 Введите ваш email: ');
             if (!email || !email.includes('@')) {
@@ -176,210 +81,276 @@ async function getGitUser() {
             }
         }
     }
-    
+
     return `[${name}](${email})`;
 }
 
 function formatMessage(message) {
-    if (!message.endsWith('.')) {
-        return message + '.';
-    }
-    return message;
+    const trimmedMessage = String(message || '').trim();
+    if (!trimmedMessage) return '';
+    return /[.!?]$/.test(trimmedMessage) ? trimmedMessage : `${trimmedMessage}.`;
 }
 
 function detectSectionFromBranch() {
     const currentBranch = getCurrentBranch();
     if (!currentBranch) return [];
-    
-    const branchLower = currentBranch.toLowerCase();
+
+    const branchType = currentBranch.split('/', 1)[0].toLowerCase();
     const sections = {
-        support: ['### 📦 Support', '### 🔐 Security'],
-        bugfix: ['### 🪲 Fixed'],
-        feature: ['### 💥 Breaking change', '### 🆕 Added', '### 🛠 Changed', '### 📜 Deprecated', '### 🗑 Removed']
+        support: [FRAGMENT_TYPES.support.section, FRAGMENT_TYPES.security.section],
+        bugfix: [FRAGMENT_TYPES.fixed.section],
+        feature: [
+            FRAGMENT_TYPES.breaking.section,
+            FRAGMENT_TYPES.added.section,
+            FRAGMENT_TYPES.changed.section,
+            FRAGMENT_TYPES.deprecated.section,
+            FRAGMENT_TYPES.removed.section
+        ]
     };
-    
-    if (branchLower.includes('support')) {
+
+    if (branchType === 'support') {
         return sections.support;
-    } else if (branchLower.includes('bugfix') || branchLower.includes('fix')) {
+    }
+    if (branchType === 'bugfix' || branchType === 'fix' || branchType === 'hotfix') {
         return sections.bugfix;
-    } else if (branchLower.includes('feature') || branchLower.includes('feat')) {
+    }
+    if (branchType === 'feature' || branchType === 'feat') {
         return sections.feature;
     }
-    
+
     return [];
 }
 
 async function selectSection(availableSections) {
-    if (availableSections.length === 0) {
-        availableSections = [
-            '### 💥 Breaking change',
-            '### 🆕 Added',
-            '### 🛠 Changed', 
-            '### 📜 Deprecated',
-            '### 🗑 Removed',
-            '### 🪲 Fixed',
-            '### 🔐 Security',
-            '### 📦 Support'
-        ];
-    }
-    
-    if (availableSections.length === 1) {
-        return availableSections[0];
+    const sections = availableSections.length > 0
+        ? availableSections
+        : Object.values(FRAGMENT_TYPES).map((config) => config.section);
+
+    if (sections.length === 1) {
+        return sections[0];
     }
-    
-    console.log(`\n📋 Выберите раздел:`);
-    availableSections.forEach((section, index) => {
+
+    console.log('\n📋 Выберите раздел:');
+    sections.forEach((section, index) => {
         console.log(`   ${index + 1}. ${section}`);
     });
-    
+
     const choice = await askQuestion('\n🔢 Введите номер раздела: ');
-    const choiceNum = parseInt(choice);
-    
-    if (isNaN(choiceNum) || choiceNum < 1 || choiceNum > availableSections.length) {
+    const choiceNum = parseInt(choice, 10);
+
+    if (Number.isNaN(choiceNum) || choiceNum < 1 || choiceNum > sections.length) {
         logError('❌', 'Неверный выбор.');
         return null;
     }
-    
-    return availableSections[choiceNum - 1];
+
+    return sections[choiceNum - 1];
 }
 
-function displayContext(lines, insertIndex, entry) {
-    console.log('\n📝 Changelog обновлен:');
-    
-    if (insertIndex > 0) {
-        console.log(`   ${colors.reset}${lines[insertIndex - 1]}${colors.reset}`);
-    }
-    
-    console.log(`   ${colors.green}${entry}${colors.reset}`);
-    
-    if (insertIndex < lines.length - 1) {
-        console.log(`   ${colors.reset}${lines[insertIndex]}${colors.reset}`);
-    }
-    console.log('');
+function sanitizeFragmentSlug(branchName, task) {
+    const branchWithoutTask = String(branchName || '').replace(new RegExp(task, 'i'), '-');
+    const slug = branchWithoutTask
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80);
+    return slug || 'change';
 }
 
-async function changelogAppend(message) {
-    return runCommand({
-        name: 'changelog append',
-        checks: [
-            { name: 'git-repo', run: requireGitRepo },
-            { name: 'changelog-exists', run: () => requireFileExists('CHANGELOG.md') },
-            { name: 'prettier-available', run: requirePrettierAvailable },
-            { name: 'changelog-prettier-check', run: requireChangelogFormatted },
-            {
-                name: 'prepare-entry',
-                run: async () => prepareChangelogEntry(message)
-            }
-        ],
-        steps: [
-            {
-                name: 'append-entry',
-                run: (ctx) => appendPreparedChangelogEntry(ctx)
-            }
-        ]
-    });
+function createFragmentPath(task, type, branchName = getCurrentBranch()) {
+    const slug = sanitizeFragmentSlug(branchName, task);
+    return path.join(CHANGELOG_DIR, `${task}-${slug}.${type}.md`);
+}
+
+function displayFragment(fragmentPath, entry) {
+    console.log('\n📝 Changelog fragment создан:');
+    console.log(`   ${colors.green}${fragmentPath}${colors.reset}`);
+    console.log(`   ${colors.green}${entry}${colors.reset}`);
+    console.log('');
 }
 
 async function prepareChangelogEntry(message) {
     try {
+        const formattedMessage = formatMessage(message);
+        if (!formattedMessage) {
+            return { ok: false, reason: 'Сообщение changelog не может быть пустым.' };
+        }
+
         const task = await extractTaskFromBranch();
         if (!task) return { ok: false, reason: 'Не удалось определить ID задачи.' };
 
         const user = await getGitUser();
         if (!user) return { ok: false, reason: 'Не удалось определить пользователя git.' };
 
-        const formattedMessage = formatMessage(message);
-        const entry = `- ${task} ${formattedMessage} ${user}`;
-        const availableSections = detectSectionFromBranch();
-        const selectedSection = await selectSection(availableSections);
+        const selectedSection = await selectSection(detectSectionFromBranch());
         if (!selectedSection) return { ok: false, reason: 'Не удалось выбрать раздел.' };
 
-        const changelog = fs.readFileSync('CHANGELOG.md', 'utf8');
-        const lines = changelog.split('\n');
-
-        let sectionIndex = -1;
-        for (let i = 0; i < lines.length; i++) {
-            if (lines[i] === selectedSection) {
-                sectionIndex = i;
-                break;
-            }
-        }
-
-        if (sectionIndex === -1) {
-            return { ok: false, reason: `Не удалось найти раздел "${selectedSection}" в CHANGELOG.md.` };
-        }
+        const type = SECTION_TO_TYPE[selectedSection];
+        if (!type) return { ok: false, reason: `Неизвестный раздел changelog: "${selectedSection}".` };
 
         return {
             ok: true,
             data: {
-                appendState: {
-                    entry,
+                fragmentState: {
+                    entry: `- ${task} ${formattedMessage} ${user}`,
+                    fragmentPath: createFragmentPath(task, type),
                     selectedSection,
-                    lines,
-                    sectionIndex
+                    type
                 }
             }
         };
     } catch (error) {
-        return { ok: false, reason: `Ошибка при подготовке записи changelog: ${error.message}` };
+        return { ok: false, reason: `Ошибка при подготовке changelog fragment: ${error.message}` };
     }
 }
 
 function appendPreparedChangelogEntry(context) {
     try {
-        const appendState = context.appendState;
-        if (!appendState) {
-            return false;
+        const fragmentState = context.fragmentState;
+        if (!fragmentState) return false;
+
+        fs.mkdirSync(CHANGELOG_DIR, { recursive: true });
+        let entries = [];
+        if (fs.existsSync(fragmentState.fragmentPath)) {
+            entries = fs.readFileSync(fragmentState.fragmentPath, 'utf8')
+                .split('\n')
+                .map((line) => line.trim())
+                .filter(Boolean);
+            if (entries.some((line) => !line.startsWith('- '))) {
+                logError('❌', 'Существующий fragment имеет неверный формат: %s', fragmentState.fragmentPath);
+                return false;
+            }
         }
 
-        const lines = [...appendState.lines];
-        const selectedSection = appendState.selectedSection;
-        const entry = appendState.entry;
-        let insertIndex = appendState.sectionIndex + 2;
-        let defaultTextLines = 0;
-
-        while (insertIndex + defaultTextLines < lines.length && lines[insertIndex + defaultTextLines].startsWith('_')) {
-            defaultTextLines++;
+        if (!entries.includes(fragmentState.entry)) {
+            entries.push(fragmentState.entry);
         }
+        fs.writeFileSync(fragmentState.fragmentPath, `${entries.join('\n')}\n`);
+        displayFragment(fragmentState.fragmentPath, fragmentState.entry);
+        logSuccess('✅', 'Запись добавлена в fragment раздела %s', fragmentState.selectedSection);
+        return true;
+    } catch (error) {
+        logError('❌', 'Ошибка при записи changelog fragment: %s', error.message);
+        return false;
+    }
+}
 
-        lines.splice(insertIndex, 0, entry);
+function changelogAppend(message) {
+    return runCommand({
+        name: 'changelog append',
+        checks: [
+            { name: 'git-repo', run: requireGitRepo },
+            { name: 'changelog-exists', run: () => requireFileExists(CHANGELOG_FILE) },
+            { name: 'prepare-fragment', run: () => prepareChangelogEntry(message) }
+        ],
+        steps: [
+            { name: 'write-fragment', run: appendPreparedChangelogEntry }
+        ]
+    });
+}
 
-        if (defaultTextLines > 0) {
-            let hasOtherEntries = false;
-            for (let i = insertIndex + 1; i < insertIndex + 1 + defaultTextLines; i++) {
-                if (lines[i] && lines[i].startsWith('- ')) {
-                    hasOtherEntries = true;
-                    break;
-                }
-            }
+function changelogCheck() {
+    return runCommand({
+        name: 'changelog check',
+        checks: [
+            { name: 'git-repo', run: requireGitRepo },
+            { name: 'changelog-exists', run: () => requireFileExists(CHANGELOG_FILE) },
+            { name: 'changelog-prettier-check', run: requireChangelogFormatted },
+            { name: 'changelog-fragments', run: requireChangelogFragments }
+        ]
+    });
+}
 
-            if (!hasOtherEntries) {
-                lines.splice(insertIndex + 1, defaultTextLines);
-            }
-        }
+function stripLegacyUnreleasedBlock(changelog) {
+    const unreleasedMatch = /^## \[Unreleased\]\s*$/m.exec(changelog);
+    if (!unreleasedMatch) return changelog;
+
+    const afterUnreleased = unreleasedMatch.index + unreleasedMatch[0].length;
+    const nextHeadingMatch = /^## /m.exec(changelog.slice(afterUnreleased));
+    const end = nextHeadingMatch ? afterUnreleased + nextHeadingMatch.index : changelog.length;
+    return `${changelog.slice(0, unreleasedMatch.index).trimEnd()}\n\n${changelog.slice(end).trimStart()}`;
+}
+
+function renderReleaseBlock(version, fragments, date = new Date().toISOString().slice(0, 10)) {
+    const fragmentsByType = new Map();
+    for (const fragment of fragments) {
+        const entries = fragmentsByType.get(fragment.type) || [];
+        entries.push(...fragment.entries);
+        fragmentsByType.set(fragment.type, entries);
+    }
+
+    const lines = [`## 🚀 [${version}] - ${date}`];
+    for (const [type, config] of Object.entries(FRAGMENT_TYPES)) {
+        const entries = fragmentsByType.get(type);
+        if (!entries || entries.length === 0) continue;
+        lines.push('', config.section, '', ...entries);
+    }
+    return `${lines.join('\n')}\n`;
+}
+
+function insertReleaseBlock(changelog, releaseBlock, version) {
+    const normalized = stripLegacyUnreleasedBlock(changelog).trimEnd();
+    const escapedVersion = String(version).replace(/\./g, '\\.');
+    const versionPattern = new RegExp(`^## 🚀 \\[${escapedVersion}\\](?:\\s|$)`, 'm');
+    if (versionPattern.test(normalized)) {
+        throw new Error(`Версия ${version} уже присутствует в ${CHANGELOG_FILE}.`);
+    }
+
+    const firstReleaseMatch = /^## /m.exec(normalized);
+    if (!firstReleaseMatch) {
+        return `${normalized}\n\n${releaseBlock}`;
+    }
+
+    return `${normalized.slice(0, firstReleaseMatch.index).trimEnd()}\n\n${releaseBlock}\n${normalized.slice(firstReleaseMatch.index).trimStart()}\n`;
+}
 
-        fs.writeFileSync('CHANGELOG.md', lines.join('\n'));
-        displayContext(lines, insertIndex, entry);
-        logSuccess('✅', 'Запись добавлена в %s', selectedSection);
+function changelogBuildRelease(context, date) {
+    try {
+        const version = context.newVersion;
+        const fragments = context.changelogFragments;
+        if (!version || !Array.isArray(fragments) || fragments.length === 0) return false;
+
+        const changelog = fs.readFileSync(CHANGELOG_FILE, 'utf8');
+        const releaseBlock = renderReleaseBlock(version, fragments, date);
+        const updatedChangelog = insertReleaseBlock(changelog, releaseBlock, version);
+        fs.writeFileSync(CHANGELOG_FILE, updatedChangelog);
+        logSuccess('📋', '%s собран из %s changelog fragments.', `CHANGELOG ${version}`, fragments.length);
         return true;
     } catch (error) {
-        logError('❌', 'Ошибка при добавлении записи changelog: %s', error.message);
+        logError('❌', 'Не удалось собрать релизный changelog: %s', error.message);
         return false;
     }
 }
 
+function changelogRemoveFragments(context) {
+    try {
+        const fragments = context.changelogFragments;
+        if (!Array.isArray(fragments) || fragments.length === 0) return false;
+        for (const fragment of fragments) {
+            fs.unlinkSync(fragment.filePath);
+        }
+        logSuccess('🧹', 'Использованные changelog fragments удалены: %s.', fragments.length);
+        return true;
+    } catch (error) {
+        logError('❌', 'Не удалось удалить changelog fragments: %s', error.message);
+        return false;
+    }
+}
 
 module.exports = {
-    changelogChangeHeader,
-    changelogRemoveEmptyChapters,
-    changelogAddUnreleasedBlock,
-    changelogCommit,
     changelogAppend,
+    changelogCheck,
     extractTaskFromBranch,
     getGitUser,
     formatMessage,
     detectSectionFromBranch,
     selectSection,
+    sanitizeFragmentSlug,
+    createFragmentPath,
     prepareChangelogEntry,
-    appendPreparedChangelogEntry
+    appendPreparedChangelogEntry,
+    stripLegacyUnreleasedBlock,
+    renderReleaseBlock,
+    insertReleaseBlock,
+    changelogBuildRelease,
+    changelogRemoveFragments
 };