@cbnventures/nova 0.12.0 → 0.13.0

package/build/src/cli/utility/changelog.js

@@ -0,0 +1,670 @@
+import { promises as fs } from 'fs';
+import { join, resolve } from 'path';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { itemChangelogAdjectives, itemChangelogCategoryBumpMap, itemChangelogNouns, itemChangelogValidBumps, itemChangelogValidCategories, itemChangelogVerbs, } from '../../lib/item.js';
+import { NovaConfig } from '../../lib/nova-config.js';
+import { PATTERN_LEADING_NEWLINES } from '../../lib/regex.js';
+import { Logger } from '../../toolkit/index.js';
+export class CLIUtilityChangelog {
+    static async run(options) {
+        const isDryRun = options.dryRun === true;
+        if (isDryRun === true) {
+            Logger.customize({
+                name: 'CLIUtilityChangelog.run',
+                purpose: 'options',
+            }).warn('Dry run enabled. File changes will not be made in this session.');
+        }
+        if (options.record === true && options.release === true) {
+            Logger.customize({
+                name: 'CLIUtilityChangelog.run',
+                purpose: 'validate',
+            }).error('Cannot use --record and --release together.');
+            process.exitCode = 1;
+            return;
+        }
+        if (options.record === true) {
+            if ((options.package === undefined
+                || options.category === undefined
+                || options.bump === undefined
+                || options.message === undefined)
+                && (options.package !== undefined
+                    || options.category !== undefined
+                    || options.bump !== undefined
+                    || options.message !== undefined)) {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.run',
+                    purpose: 'validate',
+                }).error('Non-interactive record requires --package, --category, --bump, and --message.');
+                process.exitCode = 1;
+                return;
+            }
+            await CLIUtilityChangelog.record(options);
+            return;
+        }
+        if (options.release === true) {
+            await CLIUtilityChangelog.release(options);
+            return;
+        }
+        const modeOutput = await CLIUtilityChangelog.promptWithCancel({
+            type: 'select',
+            name: 'action',
+            message: 'What would you like to do?',
+            choices: [
+                {
+                    title: 'Record a change',
+                    value: 'record',
+                },
+                {
+                    title: 'Release',
+                    value: 'release',
+                },
+            ],
+        });
+        if (modeOutput.cancelled) {
+            return;
+        }
+        const modeOutputResult = modeOutput.result;
+        if (modeOutputResult.action === undefined) {
+            return;
+        }
+        if (modeOutputResult.action === 'record') {
+            await CLIUtilityChangelog.record(options);
+        }
+        else {
+            await CLIUtilityChangelog.release(options);
+        }
+    }
+    static async record(options) {
+        const isDryRun = options.dryRun === true;
+        const novaConfig = new NovaConfig();
+        const config = await novaConfig.load();
+        const workspaces = config.workspaces ?? {};
+        const eligibleWorkspaces = Object.entries(workspaces).filter((workspace) => {
+            const workspaceConfig = workspace[1];
+            const workspaceConfigPolicy = workspaceConfig.policy;
+            return workspaceConfigPolicy !== 'freezable';
+        });
+        if (eligibleWorkspaces.length === 0) {
+            Logger.customize({
+                name: 'CLIUtilityChangelog.record',
+                purpose: 'workspaces',
+            }).error('No eligible (non-freezable) workspaces found in "nova.config.json".');
+            process.exitCode = 1;
+            return;
+        }
+        let selectedPackage;
+        let selectedCategory;
+        let selectedBump;
+        let selectedMessage;
+        if (options.package !== undefined
+            && options.category !== undefined
+            && options.bump !== undefined
+            && options.message !== undefined) {
+            const validPackageEntry = eligibleWorkspaces.find((eligibleWorkspace) => {
+                const eligibleWorkspaceConfig = eligibleWorkspace[1];
+                const eligibleWorkspaceConfigName = eligibleWorkspaceConfig.name;
+                return eligibleWorkspaceConfigName === options.package;
+            });
+            const validPackage = (validPackageEntry !== undefined) ? validPackageEntry[1].name : undefined;
+            if (validPackage === undefined) {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.record',
+                    purpose: 'validate',
+                }).error(`Package "${options.package}" is not a valid non-freezable workspace.`);
+                process.exitCode = 1;
+                return;
+            }
+            const validCategory = itemChangelogValidCategories.find((itemChangelogValidCategory) => itemChangelogValidCategory === options.category);
+            if (validCategory === undefined) {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.record',
+                    purpose: 'validate',
+                }).error(`Category "${options.category}" is invalid. Use: ${itemChangelogValidCategories.join(', ')}.`);
+                process.exitCode = 1;
+                return;
+            }
+            const validBump = itemChangelogValidBumps.find((itemChangelogValidBump) => itemChangelogValidBump === options.bump);
+            if (validBump === undefined) {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.record',
+                    purpose: 'validate',
+                }).error(`Bump type "${options.bump}" is invalid. Use: ${itemChangelogValidBumps.join(', ')}.`);
+                process.exitCode = 1;
+                return;
+            }
+            const validMessage = options.message.trim();
+            if (validMessage === '') {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.record',
+                    purpose: 'validate',
+                }).error('Message cannot be empty.');
+                process.exitCode = 1;
+                return;
+            }
+            selectedPackage = validPackage;
+            selectedCategory = validCategory;
+            selectedBump = validBump;
+            selectedMessage = validMessage;
+        }
+        else {
+            if (eligibleWorkspaces.length === 1 && eligibleWorkspaces[0] !== undefined) {
+                selectedPackage = eligibleWorkspaces[0][1].name;
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.record',
+                    purpose: 'package',
+                }).info(`Auto-selected package: ${selectedPackage}`);
+            }
+            else {
+                const packageOutput = await CLIUtilityChangelog.promptWithCancel({
+                    type: 'select',
+                    name: 'package',
+                    message: 'Select a package.',
+                    choices: eligibleWorkspaces.map((eligibleWorkspace) => {
+                        const eligibleWorkspaceConfig = eligibleWorkspace[1];
+                        const eligibleWorkspaceConfigName = eligibleWorkspaceConfig.name;
+                        const eligibleWorkspaceConfigRole = eligibleWorkspaceConfig.role;
+                        const eligibleWorkspaceConfigPolicy = eligibleWorkspaceConfig.policy;
+                        return {
+                            title: eligibleWorkspaceConfigName,
+                            description: `${eligibleWorkspaceConfigRole} · ${eligibleWorkspaceConfigPolicy}`,
+                            value: eligibleWorkspaceConfigName,
+                        };
+                    }),
+                });
+                if (packageOutput.cancelled) {
+                    return;
+                }
+                const packageOutputResult = packageOutput.result;
+                if (packageOutputResult.package === undefined) {
+                    return;
+                }
+                selectedPackage = packageOutputResult.package;
+            }
+            const categoryOutput = await CLIUtilityChangelog.promptWithCancel({
+                type: 'select',
+                name: 'category',
+                message: 'Select a category.',
+                choices: [
+                    {
+                        title: 'Updated',
+                        description: 'An enhancement to existing functionality.',
+                        value: 'updated',
+                    },
+                    {
+                        title: 'Fixed',
+                        description: 'A bug fix.',
+                        value: 'fixed',
+                    },
+                    {
+                        title: 'Added',
+                        description: 'A new feature or capability.',
+                        value: 'added',
+                    },
+                    {
+                        title: 'Removed',
+                        description: 'A removed feature or capability.',
+                        value: 'removed',
+                    },
+                ],
+            });
+            if (categoryOutput.cancelled) {
+                return;
+            }
+            const categoryOutputResult = categoryOutput.result;
+            if (categoryOutputResult.category === undefined) {
+                return;
+            }
+            selectedCategory = categoryOutputResult.category;
+            const messageOutput = await CLIUtilityChangelog.promptWithCancel({
+                type: 'text',
+                name: 'message',
+                message: 'Describe the change.',
+                validate: (value) => {
+                    if (typeof value !== 'string' || value.trim() === '') {
+                        return 'Enter a description.';
+                    }
+                    return true;
+                },
+            });
+            if (messageOutput.cancelled) {
+                return;
+            }
+            const messageOutputResult = messageOutput.result;
+            if (messageOutputResult.message === undefined) {
+                return;
+            }
+            selectedMessage = messageOutputResult.message.trim();
+            const suggestedBump = itemChangelogCategoryBumpMap[selectedCategory];
+            const bumpOutput = await CLIUtilityChangelog.promptWithCancel({
+                type: 'select',
+                name: 'bump',
+                message: 'Select version bump type.',
+                choices: [
+                    {
+                        title: 'Major',
+                        description: 'Breaking change.',
+                        value: 'major',
+                    },
+                    {
+                        title: 'Minor',
+                        description: 'New feature.',
+                        value: 'minor',
+                    },
+                    {
+                        title: 'Patch',
+                        description: 'Bug fix.',
+                        value: 'patch',
+                    },
+                ],
+                initial: itemChangelogValidBumps.indexOf(suggestedBump),
+            });
+            if (bumpOutput.cancelled) {
+                return;
+            }
+            const bumpOutputResult = bumpOutput.result;
+            if (bumpOutputResult.bump === undefined) {
+                return;
+            }
+            selectedBump = bumpOutputResult.bump;
+        }
+        const fileName = CLIUtilityChangelog.generateFileName();
+        const changelogDir = join(process.cwd(), '.changelog');
+        const filePath = join(changelogDir, `${fileName}.md`);
+        const content = [
+            '---',
+            `package: "${selectedPackage}"`,
+            `category: ${selectedCategory}`,
+            `bump: ${selectedBump}`,
+            '---',
+            '',
+            selectedMessage,
+            '',
+        ].join('\n');
+        if (isDryRun === true) {
+            Logger.customize({
+                name: 'CLIUtilityChangelog.record',
+                purpose: 'dryRun',
+                padTop: 1,
+            }).info(`Would write "${filePath}":`);
+            process.stdout.write(`\n${content}`);
+            return;
+        }
+        await fs.mkdir(changelogDir, { recursive: true });
+        const readmePath = join(changelogDir, 'README.md');
+        try {
+            await fs.access(readmePath);
+        }
+        catch {
+            await fs.writeFile(readmePath, [
+                '# Changelog',
+                '',
+                'Welcome! This folder was automatically generated by `nova utility changelog`, a tool designed for managing versioning and release notes in your monorepo. To learn more about how it works, visit the [documentation](https://cbnventures.github.io/nova/docs/cli/utilities/changelog).',
+                '',
+            ].join('\n'), 'utf-8');
+        }
+        await fs.writeFile(filePath, content, 'utf-8');
+        Logger.customize({
+            name: 'CLIUtilityChangelog.record',
+            purpose: 'saved',
+            padTop: 1,
+        }).info(`Recorded change to "${filePath}".`);
+    }
+    static async release(options) {
+        const isDryRun = options.dryRun === true;
+        const isNonInteractive = options.release === true;
+        const entries = await CLIUtilityChangelog.parseEntries();
+        if (entries.length === 0) {
+            Logger.customize({
+                name: 'CLIUtilityChangelog.release',
+                purpose: 'entries',
+            }).info('No changelog entries found in ".changelog/".');
+            return;
+        }
+        const grouped = new Map();
+        for (const entry of entries) {
+            const existing = grouped.get(entry.package) ?? [];
+            existing.push(entry);
+            grouped.set(entry.package, existing);
+        }
+        const novaConfig = new NovaConfig();
+        const config = await novaConfig.load();
+        const workspaces = config.workspaces ?? {};
+        const bumpPriority = {
+            major: 3,
+            minor: 2,
+            patch: 1,
+        };
+        const releases = [];
+        for (const entry of grouped) {
+            const packageName = entry[0];
+            const packageEntries = entry[1];
+            const workspaceEntry = Object.entries(workspaces).find((workspace) => {
+                const workspaceConfig = workspace[1];
+                const workspaceConfigName = workspaceConfig.name;
+                return workspaceConfigName === packageName;
+            });
+            if (workspaceEntry === undefined) {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.release',
+                    purpose: 'workspace',
+                }).error(`Package "${packageName}" not found in "nova.config.json".`);
+                process.exitCode = 1;
+                return;
+            }
+            const workspacePath = workspaceEntry[0];
+            const packageDir = resolve(process.cwd(), workspacePath);
+            const packageJsonPath = join(packageDir, 'package.json');
+            let packageJsonRaw;
+            try {
+                packageJsonRaw = await fs.readFile(packageJsonPath, 'utf-8');
+            }
+            catch {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.release',
+                    purpose: 'readPackageJson',
+                }).error(`Unable to read "${packageJsonPath}".`);
+                process.exitCode = 1;
+                return;
+            }
+            let packageJson;
+            try {
+                packageJson = JSON.parse(packageJsonRaw);
+            }
+            catch {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.release',
+                    purpose: 'parsePackageJson',
+                }).error(`Unable to parse "${packageJsonPath}".`);
+                process.exitCode = 1;
+                return;
+            }
+            const currentVersion = (typeof packageJson['version'] === 'string') ? packageJson['version'] : undefined;
+            if (currentVersion === undefined) {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.release',
+                    purpose: 'version',
+                }).error(`No "version" field found in "${packageJsonPath}".`);
+                process.exitCode = 1;
+                return;
+            }
+            let highestBump = 'patch';
+            for (const entry of packageEntries) {
+                if (bumpPriority[entry.bump] > bumpPriority[highestBump]) {
+                    highestBump = entry.bump;
+                }
+            }
+            const versionParts = currentVersion.split('.').map(Number);
+            const versionPartsMajor = versionParts[0] ?? 0;
+            const versionPartsMinor = versionParts[1] ?? 0;
+            const versionPartsPatch = versionParts[2] ?? 0;
+            let newVersion = currentVersion;
+            switch (highestBump) {
+                case 'major': {
+                    newVersion = `${versionPartsMajor + 1}.0.0`;
+                    break;
+                }
+                case 'minor': {
+                    newVersion = `${versionPartsMajor}.${versionPartsMinor + 1}.0`;
+                    break;
+                }
+                case 'patch': {
+                    newVersion = `${versionPartsMajor}.${versionPartsMinor}.${versionPartsPatch + 1}`;
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+            releases.push({
+                packageName,
+                packageDir,
+                currentVersion,
+                newVersion,
+                highestBump,
+                entries: packageEntries,
+            });
+        }
+        Logger.customize({
+            name: 'CLIUtilityChangelog.release',
+            purpose: 'summary',
+        }).info('Release summary:');
+        const categoryOrder = [
+            'updated',
+            'fixed',
+            'added',
+            'removed',
+        ];
+        for (const release of releases) {
+            const releasePackageName = release.packageName;
+            const releaseCurrentVersion = release.currentVersion;
+            const releaseNewVersion = release.newVersion;
+            const releaseHighestBump = release.highestBump;
+            const releaseEntries = release.entries;
+            process.stdout.write(`\n  ${chalk.bold(releasePackageName)}: ${releaseCurrentVersion} → ${chalk.green(releaseNewVersion)} (${releaseHighestBump})\n`);
+            for (const category of categoryOrder) {
+                const categoryEntries = releaseEntries.filter((releaseEntry) => releaseEntry.category === category);
+                if (categoryEntries.length === 0) {
+                    continue;
+                }
+                process.stdout.write(`    ${chalk.yellow(category.toUpperCase())}:\n`);
+                for (const categoryEntry of categoryEntries) {
+                    const categoryEntryMessage = categoryEntry.message;
+                    process.stdout.write(`      - ${categoryEntryMessage}\n`);
+                }
+            }
+        }
+        process.stdout.write('\n');
+        if (isNonInteractive !== true) {
+            const confirmOutput = await CLIUtilityChangelog.promptWithCancel({
+                type: 'confirm',
+                name: 'confirm',
+                message: 'Proceed with release?',
+                initial: false,
+            });
+            if (confirmOutput.cancelled) {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.release',
+                    purpose: 'cancelled',
+                }).info('Release cancelled.');
+                return;
+            }
+            const confirmOutputResult = confirmOutput.result;
+            if (confirmOutputResult.confirm !== true) {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.release',
+                    purpose: 'cancelled',
+                }).info('Release cancelled.');
+                return;
+            }
+        }
+        if (isDryRun === true) {
+            Logger.customize({
+                name: 'CLIUtilityChangelog.release',
+                purpose: 'dryRun',
+            }).info('Dry run complete. No files were modified.');
+            return;
+        }
+        for (const release of releases) {
+            const releasePackageName = release.packageName;
+            const releasePackageDir = release.packageDir;
+            const releaseNewVersion = release.newVersion;
+            const releaseEntries = release.entries;
+            const packageJsonPath = join(releasePackageDir, 'package.json');
+            const packageJsonRaw = await fs.readFile(packageJsonPath, 'utf-8');
+            const packageJson = JSON.parse(packageJsonRaw);
+            Reflect.set(packageJson, 'version', releaseNewVersion);
+            const updatedPackageJson = JSON.stringify(packageJson, null, 2);
+            const updatedContents = `${updatedPackageJson}\n`;
+            await fs.writeFile(packageJsonPath, updatedContents, 'utf-8');
+            Logger.customize({
+                name: 'CLIUtilityChangelog.release',
+                purpose: 'bumpVersion',
+            }).info(`Updated "${packageJsonPath}" version to ${releaseNewVersion}.`);
+            await CLIUtilityChangelog.writeChangelog(releasePackageDir, releasePackageName, releaseNewVersion, releaseEntries);
+            Logger.customize({
+                name: 'CLIUtilityChangelog.release',
+                purpose: 'writeChangelog',
+            }).info(`Updated "CHANGELOG.md" for ${releasePackageName}.`);
+        }
+        for (const entry of entries) {
+            await fs.unlink(entry.filePath);
+        }
+        Logger.customize({
+            name: 'CLIUtilityChangelog.release',
+            purpose: 'complete',
+            padTop: 1,
+        }).info('Release complete.');
+    }
+    static async parseEntries() {
+        const changelogDir = join(process.cwd(), '.changelog');
+        const entries = [];
+        let files;
+        try {
+            const dirEntries = await fs.readdir(changelogDir);
+            files = dirEntries.filter((file) => file.endsWith('.md'));
+        }
+        catch {
+            return entries;
+        }
+        for (const file of files) {
+            const filePath = join(changelogDir, file);
+            const content = await fs.readFile(filePath, 'utf-8');
+            const lines = content.split('\n');
+            if (lines[0] !== '---') {
+                continue;
+            }
+            let endIndex = -1;
+            for (let i = 1; i < lines.length; i += 1) {
+                if (lines[i] === '---') {
+                    endIndex = i;
+                    break;
+                }
+            }
+            if (endIndex === -1) {
+                continue;
+            }
+            let entryPackage;
+            let entryCategory;
+            let entryBump;
+            for (let i = 1; i < endIndex; i += 1) {
+                const line = lines[i];
+                if (line === undefined) {
+                    continue;
+                }
+                const colonIndex = line.indexOf(':');
+                if (colonIndex === -1) {
+                    continue;
+                }
+                const key = line.slice(0, colonIndex).trim();
+                let value = line.slice(colonIndex + 1).trim();
+                if ((value.startsWith('"')
+                    && value.endsWith('"'))
+                    || (value.startsWith('\'')
+                        && value.endsWith('\''))) {
+                    value = value.slice(1, -1);
+                }
+                if (key === 'package') {
+                    entryPackage = value;
+                }
+                else if (key === 'category') {
+                    entryCategory = itemChangelogValidCategories.find((itemChangelogValidCategory) => itemChangelogValidCategory === value);
+                }
+                else if (key === 'bump') {
+                    entryBump = itemChangelogValidBumps.find((itemChangelogValidBump) => itemChangelogValidBump === value);
+                }
+            }
+            const message = lines.slice(endIndex + 1).join('\n').trim();
+            if (entryPackage === undefined
+                || entryCategory === undefined
+                || entryBump === undefined
+                || message === '') {
+                Logger.customize({
+                    name: 'CLIUtilityChangelog.parseEntries',
+                    purpose: 'skip',
+                }).warn(`Skipping "${file}": invalid or missing front matter.`);
+                continue;
+            }
+            entries.push({
+                package: entryPackage,
+                category: entryCategory,
+                bump: entryBump,
+                message,
+                filePath,
+            });
+        }
+        return entries;
+    }
+    static async writeChangelog(packageDir, packageName, version, entries) {
+        const changelogPath = join(packageDir, 'CHANGELOG.md');
+        const today = new Date();
+        const dateString = [
+            today.getFullYear(),
+            (today.getMonth() + 1).toString().padStart(2, '0'),
+            today.getDate().toString().padStart(2, '0'),
+        ].join('-');
+        const byCategory = new Map();
+        for (const entry of entries) {
+            const existing = byCategory.get(entry.category) ?? [];
+            existing.push(entry.message);
+            byCategory.set(entry.category, existing);
+        }
+        const categoryOrder = ['updated', 'fixed', 'added', 'removed'];
+        const sectionParts = [];
+        sectionParts.push(`## ${version} (${dateString})`);
+        for (const category of categoryOrder) {
+            const messages = byCategory.get(category);
+            if (messages === undefined || messages.length === 0) {
+                continue;
+            }
+            sectionParts.push('');
+            sectionParts.push(`### ${category.toUpperCase()}`);
+            for (const message of messages) {
+                sectionParts.push(`- ${message}`);
+            }
+        }
+        const newSection = sectionParts.join('\n');
+        let existingContent = '';
+        try {
+            existingContent = await fs.readFile(changelogPath, 'utf-8');
+        }
+        catch {
+        }
+        const packageHeading = `# ${packageName}`;
+        if (existingContent === '') {
+            await fs.writeFile(changelogPath, `${packageHeading}\n\n${newSection}\n`, 'utf-8');
+        }
+        else if (existingContent.startsWith(packageHeading)) {
+            const afterHeading = existingContent.slice(packageHeading.length);
+            await fs.writeFile(changelogPath, `${packageHeading}\n\n${newSection}\n${afterHeading.replace(PATTERN_LEADING_NEWLINES, '\n')}`, 'utf-8');
+        }
+        else {
+            await fs.writeFile(changelogPath, `${packageHeading}\n\n${newSection}\n\n${existingContent}`, 'utf-8');
+        }
+    }
+    static async promptWithCancel(questions) {
+        let cancelled = false;
+        const result = await prompts(questions, {
+            onCancel: () => {
+                cancelled = true;
+                return false;
+            },
+        });
+        if (cancelled) {
+            return {
+                cancelled: true,
+            };
+        }
+        return {
+            cancelled: false,
+            result,
+        };
+    }
+    static generateFileName() {
+        const adjective = itemChangelogAdjectives[Math.floor(Math.random() * itemChangelogAdjectives.length)];
+        const noun = itemChangelogNouns[Math.floor(Math.random() * itemChangelogNouns.length)];
+        const verb = itemChangelogVerbs[Math.floor(Math.random() * itemChangelogVerbs.length)];
+        return `${adjective}-${noun}-${verb}`;
+    }
+}
+//# sourceMappingURL=changelog.js.map