@cbnventures/nova 0.13.1 → 0.15.0

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

@@ -2,51 +2,51 @@ 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 { libItemChangelogAdjectives, libItemChangelogCategoryBumpMap, libItemChangelogNouns, libItemChangelogOrderedCategories, libItemChangelogValidBumps, libItemChangelogValidCategories, libItemChangelogVerbs, } from '../../lib/item.js';
+import { LibNovaConfig } from '../../lib/nova-config.js';
+import { LIB_REGEX_PATTERN_LEADING_NEWLINES } from '../../lib/regex.js';
 import { Logger } from '../../toolkit/index.js';
-export class CLIUtilityChangelog {
+export class CliUtilityChangelog {
     static async run(options) {
-        const isDryRun = options.dryRun === true;
+        const isDryRun = options['dryRun'] === true;
         if (isDryRun === true) {
             Logger.customize({
-                name: 'CLIUtilityChangelog.run',
+                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) {
+        if (options['record'] === true && options['release'] === true) {
             Logger.customize({
-                name: 'CLIUtilityChangelog.run',
+                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)) {
+        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',
+                    name: 'CliUtilityChangelog.run',
                     purpose: 'validate',
                 }).error('Non-interactive record requires --package, --category, --bump, and --message.');
                 process.exitCode = 1;
                 return;
             }
-            await CLIUtilityChangelog.record(options);
+            await CliUtilityChangelog.record(options);
             return;
         }
-        if (options.release === true) {
-            await CLIUtilityChangelog.release(options);
+        if (options['release'] === true) {
+            await CliUtilityChangelog.release(options);
             return;
         }
-        const modeOutput = await CLIUtilityChangelog.promptWithCancel({
+        const modeOutput = await CliUtilityChangelog.promptWithCancel({
             type: 'select',
             name: 'action',
             message: 'What would you like to do?',
@@ -61,82 +61,82 @@ export class CLIUtilityChangelog {
                 },
             ],
         });
-        if (modeOutput.cancelled) {
+        if (modeOutput['cancelled'] === true) {
             return;
         }
-        const modeOutputResult = modeOutput.result;
+        const modeOutputResult = modeOutput['result'];
         if (modeOutputResult.action === undefined) {
             return;
         }
         if (modeOutputResult.action === 'record') {
-            await CLIUtilityChangelog.record(options);
+            await CliUtilityChangelog.record(options);
         }
         else {
-            await CLIUtilityChangelog.release(options);
+            await CliUtilityChangelog.release(options);
         }
+        return;
     }
     static async record(options) {
-        const isDryRun = options.dryRun === true;
-        const novaConfig = new NovaConfig();
-        const config = await novaConfig.load();
-        const workspaces = config.workspaces ?? {};
+        const isDryRun = options['dryRun'] === true;
+        const config = await new LibNovaConfig().load();
+        const workspaces = config['workspaces'] ?? {};
         const eligibleWorkspaces = Object.entries(workspaces).filter((workspace) => {
             const workspaceConfig = workspace[1];
-            const workspaceConfigPolicy = workspaceConfig.policy;
+            const workspaceConfigPolicy = workspaceConfig['policy'];
             return workspaceConfigPolicy !== 'freezable';
         });
         if (eligibleWorkspaces.length === 0) {
             Logger.customize({
-                name: 'CLIUtilityChangelog.record',
+                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) {
+        let selectedPackage = undefined;
+        let selectedCategory = undefined;
+        let selectedBump = undefined;
+        let selectedMessage = undefined;
+        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 eligibleWorkspaceConfigName = eligibleWorkspaceConfig['name'];
+                return eligibleWorkspaceConfigName === options['package'];
             });
-            const validPackage = (validPackageEntry !== undefined) ? validPackageEntry[1].name : undefined;
+            const validPackage = (validPackageEntry !== undefined) ? validPackageEntry[1]['name'] : undefined;
             if (validPackage === undefined) {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.record',
+                    name: 'CliUtilityChangelog.record',
                     purpose: 'validate',
-                }).error(`Package "${options.package}" is not a valid non-freezable workspace.`);
+                }).error(`Package "${options['package']}" is not a valid non-freezable workspace.`);
                 process.exitCode = 1;
                 return;
             }
-            const validCategory = itemChangelogValidCategories.find((itemChangelogValidCategory) => itemChangelogValidCategory === options.category);
+            const validCategory = libItemChangelogValidCategories.find((libItemChangelogValidCategory) => libItemChangelogValidCategory === options['category']);
             if (validCategory === undefined) {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.record',
+                    name: 'CliUtilityChangelog.record',
                     purpose: 'validate',
-                }).error(`Category "${options.category}" is invalid. Use: ${itemChangelogValidCategories.join(', ')}.`);
+                }).error(`Category "${options['category']}" is invalid. Use: ${libItemChangelogValidCategories.join(', ')}.`);
                 process.exitCode = 1;
                 return;
             }
-            const validBump = itemChangelogValidBumps.find((itemChangelogValidBump) => itemChangelogValidBump === options.bump);
+            const validBump = libItemChangelogValidBumps.find((libItemChangelogValidBump) => libItemChangelogValidBump === options['bump']);
             if (validBump === undefined) {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.record',
+                    name: 'CliUtilityChangelog.record',
                     purpose: 'validate',
-                }).error(`Bump type "${options.bump}" is invalid. Use: ${itemChangelogValidBumps.join(', ')}.`);
+                }).error(`Bump type "${options['bump']}" is invalid. Use: ${libItemChangelogValidBumps.join(', ')}.`);
                 process.exitCode = 1;
                 return;
             }
-            const validMessage = options.message.trim();
+            const validMessage = options['message'].trim();
             if (validMessage === '') {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.record',
+                    name: 'CliUtilityChangelog.record',
                     purpose: 'validate',
                 }).error('Message cannot be empty.');
                 process.exitCode = 1;
@@ -149,22 +149,22 @@ export class CLIUtilityChangelog {
         }
         else {
             if (eligibleWorkspaces.length === 1 && eligibleWorkspaces[0] !== undefined) {
-                selectedPackage = eligibleWorkspaces[0][1].name;
+                selectedPackage = eligibleWorkspaces[0][1]['name'];
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.record',
+                    name: 'CliUtilityChangelog.record',
                     purpose: 'package',
                 }).info(`Auto-selected package: ${selectedPackage}`);
             }
             else {
-                const packageOutput = await CLIUtilityChangelog.promptWithCancel({
+                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;
+                        const eligibleWorkspaceConfigName = eligibleWorkspaceConfig['name'];
+                        const eligibleWorkspaceConfigRole = eligibleWorkspaceConfig['role'];
+                        const eligibleWorkspaceConfigPolicy = eligibleWorkspaceConfig['policy'];
                         return {
                             title: eligibleWorkspaceConfigName,
                             description: `${eligibleWorkspaceConfigRole} · ${eligibleWorkspaceConfigPolicy}`,
@@ -172,16 +172,16 @@ export class CLIUtilityChangelog {
                         };
                     }),
                 });
-                if (packageOutput.cancelled) {
+                if (packageOutput['cancelled'] === true) {
                     return;
                 }
-                const packageOutputResult = packageOutput.result;
+                const packageOutputResult = packageOutput['result'];
                 if (packageOutputResult.package === undefined) {
                     return;
                 }
                 selectedPackage = packageOutputResult.package;
             }
-            const categoryOutput = await CLIUtilityChangelog.promptWithCancel({
+            const categoryOutput = await CliUtilityChangelog.promptWithCancel({
                 type: 'select',
                 name: 'category',
                 message: 'Select a category.',
@@ -208,15 +208,15 @@ export class CLIUtilityChangelog {
                     },
                 ],
             });
-            if (categoryOutput.cancelled) {
+            if (categoryOutput['cancelled'] === true) {
                 return;
             }
-            const categoryOutputResult = categoryOutput.result;
+            const categoryOutputResult = categoryOutput['result'];
             if (categoryOutputResult.category === undefined) {
                 return;
             }
             selectedCategory = categoryOutputResult.category;
-            const messageOutput = await CLIUtilityChangelog.promptWithCancel({
+            const messageOutput = await CliUtilityChangelog.promptWithCancel({
                 type: 'text',
                 name: 'message',
                 message: 'Describe the change.',
@@ -227,16 +227,16 @@ export class CLIUtilityChangelog {
                     return true;
                 },
             });
-            if (messageOutput.cancelled) {
+            if (messageOutput['cancelled'] === true) {
                 return;
             }
-            const messageOutputResult = messageOutput.result;
+            const messageOutputResult = messageOutput['result'];
             if (messageOutputResult.message === undefined) {
                 return;
             }
             selectedMessage = messageOutputResult.message.trim();
-            const suggestedBump = itemChangelogCategoryBumpMap[selectedCategory];
-            const bumpOutput = await CLIUtilityChangelog.promptWithCancel({
+            const suggestedBump = libItemChangelogCategoryBumpMap[selectedCategory];
+            const bumpOutput = await CliUtilityChangelog.promptWithCancel({
                 type: 'select',
                 name: 'bump',
                 message: 'Select version bump type.',
@@ -257,20 +257,21 @@ export class CLIUtilityChangelog {
                         value: 'patch',
                     },
                 ],
-                initial: itemChangelogValidBumps.indexOf(suggestedBump),
+                initial: libItemChangelogValidBumps.indexOf(suggestedBump),
             });
-            if (bumpOutput.cancelled) {
+            if (bumpOutput['cancelled'] === true) {
                 return;
             }
-            const bumpOutputResult = bumpOutput.result;
+            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 fileName = CliUtilityChangelog.generateFileName();
+        const currentDirectory = process.cwd();
+        const changelogDirectory = join(currentDirectory, '.changelog');
+        const filePath = join(changelogDirectory, `${fileName}.md`);
         const content = [
             '---',
             `package: "${selectedPackage}"`,
@@ -283,115 +284,121 @@ export class CLIUtilityChangelog {
         ].join('\n');
         if (isDryRun === true) {
             Logger.customize({
-                name: 'CLIUtilityChangelog.record',
+                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');
+        await fs.mkdir(changelogDirectory, { recursive: true });
+        const readmePath = join(changelogDirectory, 'README.md');
         try {
             await fs.access(readmePath);
         }
         catch {
-            await fs.writeFile(readmePath, [
+            const readmeContent = [
                 '# 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).',
+                '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://nova.cbnventures.io/docs/cli/utilities/changelog).',
                 '',
-            ].join('\n'), 'utf-8');
+            ].join('\n');
+            await fs.writeFile(readmePath, readmeContent, 'utf-8');
         }
         await fs.writeFile(filePath, content, 'utf-8');
         Logger.customize({
-            name: 'CLIUtilityChangelog.record',
+            name: 'CliUtilityChangelog.record',
             purpose: 'saved',
             padTop: 1,
         }).info(`Recorded change to "${filePath}".`);
+        return;
     }
     static async release(options) {
-        const isDryRun = options.dryRun === true;
-        const isNonInteractive = options.release === true;
-        const entries = await CLIUtilityChangelog.parseEntries();
+        const isDryRun = options['dryRun'] === true;
+        const isNonInteractive = options['release'] === true;
+        const entries = await CliUtilityChangelog.parseEntries();
         if (entries.length === 0) {
             Logger.customize({
-                name: 'CLIUtilityChangelog.release',
+                name: 'CliUtilityChangelog.release',
                 purpose: 'entries',
             }).info('No changelog entries found in ".changelog/".');
             return;
         }
-        const grouped = new Map();
+        const groups = new Map();
         for (const entry of entries) {
-            const existing = grouped.get(entry.package) ?? [];
+            const existing = groups.get(entry['package']) ?? [];
             existing.push(entry);
-            grouped.set(entry.package, existing);
+            groups.set(entry['package'], existing);
         }
-        const novaConfig = new NovaConfig();
-        const config = await novaConfig.load();
-        const workspaces = config.workspaces ?? {};
+        const config = await new LibNovaConfig().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];
+        for (const group of groups) {
+            const packageName = group[0];
+            const packageEntries = group[1];
             const workspaceEntry = Object.entries(workspaces).find((workspace) => {
                 const workspaceConfig = workspace[1];
-                const workspaceConfigName = workspaceConfig.name;
+                const workspaceConfigName = workspaceConfig['name'];
                 return workspaceConfigName === packageName;
             });
             if (workspaceEntry === undefined) {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.release',
+                    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;
+            const currentDirectory = process.cwd();
+            const packageDirectory = resolve(currentDirectory, workspacePath);
+            const packageJsonPath = join(packageDirectory, 'package.json');
+            let packageJsonRaw = undefined;
             try {
                 packageJsonRaw = await fs.readFile(packageJsonPath, 'utf-8');
             }
             catch {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.release',
+                    name: 'CliUtilityChangelog.release',
                     purpose: 'readPackageJson',
                 }).error(`Unable to read "${packageJsonPath}".`);
                 process.exitCode = 1;
                 return;
             }
-            let packageJson;
+            let parsedPackageJson = undefined;
             try {
-                packageJson = JSON.parse(packageJsonRaw);
+                parsedPackageJson = JSON.parse(packageJsonRaw);
             }
             catch {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.release',
+                    name: 'CliUtilityChangelog.release',
                     purpose: 'parsePackageJson',
                 }).error(`Unable to parse "${packageJsonPath}".`);
                 process.exitCode = 1;
                 return;
             }
-            const currentVersion = (typeof packageJson['version'] === 'string') ? packageJson['version'] : undefined;
+            if (parsedPackageJson === undefined) {
+                process.exitCode = 1;
+                return;
+            }
+            const currentVersion = (typeof parsedPackageJson['version'] === 'string') ? parsedPackageJson['version'] : undefined;
             if (currentVersion === undefined) {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.release',
+                    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;
+            for (const packageEntry of packageEntries) {
+                if (bumpPriority[packageEntry['bump']] > bumpPriority[highestBump]) {
+                    highestBump = packageEntry['bump'];
                 }
             }
             const versionParts = currentVersion.split('.').map(Number);
@@ -418,7 +425,7 @@ export class CLIUtilityChangelog {
             }
             releases.push({
                 packageName,
-                packageDir,
+                packageDirectory,
                 currentVersion,
                 newVersion,
                 highestBump,
@@ -426,7 +433,7 @@ export class CLIUtilityChangelog {
             });
         }
         Logger.customize({
-            name: 'CLIUtilityChangelog.release',
+            name: 'CliUtilityChangelog.release',
             purpose: 'summary',
         }).info('Release summary:');
         const categoryOrder = [
@@ -436,43 +443,44 @@ export class CLIUtilityChangelog {
             '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;
+            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);
+                const categoryEntries = releaseEntries.filter((releaseEntry) => releaseEntry['category'] === category);
                 if (categoryEntries.length === 0) {
                     continue;
                 }
-                process.stdout.write(`    ${chalk.yellow(category.toUpperCase())}:\n`);
+                const categoryLabel = category.toUpperCase();
+                process.stdout.write(`    ${chalk.yellow(categoryLabel)}:\n`);
                 for (const categoryEntry of categoryEntries) {
-                    const categoryEntryMessage = categoryEntry.message;
+                    const categoryEntryMessage = categoryEntry['message'];
                     process.stdout.write(`      - ${categoryEntryMessage}\n`);
                 }
             }
         }
         process.stdout.write('\n');
         if (isNonInteractive !== true) {
-            const confirmOutput = await CLIUtilityChangelog.promptWithCancel({
+            const confirmOutput = await CliUtilityChangelog.promptWithCancel({
                 type: 'confirm',
                 name: 'confirm',
                 message: 'Proceed with release?',
                 initial: false,
             });
-            if (confirmOutput.cancelled) {
+            if (confirmOutput['cancelled'] === true) {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.release',
+                    name: 'CliUtilityChangelog.release',
                     purpose: 'cancelled',
                 }).info('Release cancelled.');
                 return;
             }
-            const confirmOutputResult = confirmOutput.result;
+            const confirmOutputResult = confirmOutput['result'];
             if (confirmOutputResult.confirm !== true) {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.release',
+                    name: 'CliUtilityChangelog.release',
                     purpose: 'cancelled',
                 }).info('Release cancelled.');
                 return;
@@ -480,55 +488,60 @@ export class CLIUtilityChangelog {
         }
         if (isDryRun === true) {
             Logger.customize({
-                name: 'CLIUtilityChangelog.release',
+                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);
+            const releasePackageName = release['packageName'];
+            const releasePackageDirectory = release['packageDirectory'];
+            const releaseNewVersion = release['newVersion'];
+            const releaseEntries = release['entries'];
+            const packageJsonPath = join(releasePackageDirectory, 'package.json');
+            const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+            if (packageJson === null
+                || typeof packageJson !== 'object'
+                || typeof packageJson['version'] !== 'string') {
+                throw new Error(`Invalid package.json at "${packageJsonPath}": missing or non-string "version" field.`);
+            }
             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',
+                name: 'CliUtilityChangelog.release',
                 purpose: 'bumpVersion',
             }).info(`Updated "${packageJsonPath}" version to ${releaseNewVersion}.`);
-            await CLIUtilityChangelog.writeChangelog(releasePackageDir, releasePackageName, releaseNewVersion, releaseEntries);
+            await CliUtilityChangelog.writeChangelog(releasePackageDirectory, releasePackageName, releaseNewVersion, releaseEntries);
             Logger.customize({
-                name: 'CLIUtilityChangelog.release',
+                name: 'CliUtilityChangelog.release',
                 purpose: 'writeChangelog',
             }).info(`Updated "CHANGELOG.md" for ${releasePackageName}.`);
         }
         for (const entry of entries) {
-            await fs.unlink(entry.filePath);
+            await fs.unlink(entry['filePath']);
         }
         Logger.customize({
-            name: 'CLIUtilityChangelog.release',
+            name: 'CliUtilityChangelog.release',
             purpose: 'complete',
             padTop: 1,
         }).info('Release complete.');
+        return;
     }
     static async parseEntries() {
-        const changelogDir = join(process.cwd(), '.changelog');
+        const currentDirectory = process.cwd();
+        const changelogDirectory = join(currentDirectory, '.changelog');
         const entries = [];
-        let files;
+        let entryFiles = undefined;
         try {
-            const dirEntries = await fs.readdir(changelogDir);
-            files = dirEntries.filter((file) => file.endsWith('.md'));
+            entryFiles = (await fs.readdir(changelogDirectory)).filter((directoryEntry) => directoryEntry.endsWith('.md'));
         }
         catch {
             return entries;
         }
-        for (const file of files) {
-            const filePath = join(changelogDir, file);
+        for (const entryFile of entryFiles) {
+            const filePath = join(changelogDirectory, entryFile);
             const content = await fs.readFile(filePath, 'utf-8');
             const lines = content.split('\n');
             if (lines[0] !== '---') {
@@ -544,9 +557,9 @@ export class CLIUtilityChangelog {
             if (endIndex === -1) {
                 continue;
             }
-            let entryPackage;
-            let entryCategory;
-            let entryBump;
+            let entryPackage = undefined;
+            let entryCategory = undefined;
+            let entryBump = undefined;
             for (let i = 1; i < endIndex; i += 1) {
                 const line = lines[i];
                 if (line === undefined) {
@@ -558,20 +571,20 @@ export class CLIUtilityChangelog {
                 }
                 const key = line.slice(0, colonIndex).trim();
                 let value = line.slice(colonIndex + 1).trim();
-                if ((value.startsWith('"')
-                    && value.endsWith('"'))
-                    || (value.startsWith('\'')
-                        && value.endsWith('\''))) {
+                if ((value.startsWith('"') === true
+                    && value.endsWith('"') === true)
+                    || (value.startsWith('\'') === true
+                        && value.endsWith('\'') === true)) {
                     value = value.slice(1, -1);
                 }
                 if (key === 'package') {
                     entryPackage = value;
                 }
                 else if (key === 'category') {
-                    entryCategory = itemChangelogValidCategories.find((itemChangelogValidCategory) => itemChangelogValidCategory === value);
+                    entryCategory = libItemChangelogValidCategories.find((libItemChangelogValidCategory) => libItemChangelogValidCategory === value);
                 }
                 else if (key === 'bump') {
-                    entryBump = itemChangelogValidBumps.find((itemChangelogValidBump) => itemChangelogValidBump === value);
+                    entryBump = libItemChangelogValidBumps.find((libItemChangelogValidBump) => libItemChangelogValidBump === value);
                 }
             }
             const message = lines.slice(endIndex + 1).join('\n').trim();
@@ -580,9 +593,9 @@ export class CLIUtilityChangelog {
                 || entryBump === undefined
                 || message === '') {
                 Logger.customize({
-                    name: 'CLIUtilityChangelog.parseEntries',
+                    name: 'CliUtilityChangelog.parseEntries',
                     purpose: 'skip',
-                }).warn(`Skipping "${file}": invalid or missing front matter.`);
+                }).warn(`Skipping "${entryFile}": invalid or missing front matter.`);
                 continue;
             }
             entries.push({
@@ -595,8 +608,8 @@ export class CLIUtilityChangelog {
         }
         return entries;
     }
-    static async writeChangelog(packageDir, packageName, version, entries) {
-        const changelogPath = join(packageDir, 'CHANGELOG.md');
+    static async writeChangelog(packageDirectory, packageName, version, entries) {
+        const changelogPath = join(packageDirectory, 'CHANGELOG.md');
         const today = new Date();
         const dateString = [
             today.getFullYear(),
@@ -605,13 +618,13 @@ export class CLIUtilityChangelog {
         ].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 existing = byCategory.get(entry['category']) ?? [];
+            existing.push(entry['message']);
+            byCategory.set(entry['category'], existing);
         }
-        const categoryOrder = ['updated', 'fixed', 'added', 'removed'];
+        const categoryOrder = [...libItemChangelogOrderedCategories];
         const sectionParts = [];
-        sectionParts.push(`## ${version} (${dateString})`);
+        sectionParts.push(`## ${version} - ${dateString}`);
         for (const category of categoryOrder) {
             const messages = byCategory.get(category);
             if (messages === undefined || messages.length === 0) {
@@ -632,25 +645,46 @@ export class CLIUtilityChangelog {
         }
         const packageHeading = `# ${packageName}`;
         if (existingContent === '') {
-            await fs.writeFile(changelogPath, `${packageHeading}\n\n${newSection}\n`, 'utf-8');
+            const newContent = [
+                packageHeading,
+                '',
+                newSection,
+                '',
+            ].join('\n');
+            await fs.writeFile(changelogPath, newContent, 'utf-8');
         }
-        else if (existingContent.startsWith(packageHeading)) {
+        else if (existingContent.startsWith(packageHeading) === true) {
             const afterHeading = existingContent.slice(packageHeading.length);
-            await fs.writeFile(changelogPath, `${packageHeading}\n\n${newSection}\n${afterHeading.replace(PATTERN_LEADING_NEWLINES, '\n')}`, 'utf-8');
+            const trimmedAfterHeading = afterHeading.replace(LIB_REGEX_PATTERN_LEADING_NEWLINES, '\n');
+            const prependedContent = [
+                packageHeading,
+                '',
+                newSection,
+                trimmedAfterHeading,
+            ].join('\n');
+            await fs.writeFile(changelogPath, prependedContent, 'utf-8');
         }
         else {
-            await fs.writeFile(changelogPath, `${packageHeading}\n\n${newSection}\n\n${existingContent}`, 'utf-8');
+            const prependedContent = [
+                packageHeading,
+                '',
+                newSection,
+                '',
+                existingContent,
+            ].join('\n');
+            await fs.writeFile(changelogPath, prependedContent, 'utf-8');
         }
+        return;
     }
     static async promptWithCancel(questions) {
         let cancelled = false;
         const result = await prompts(questions, {
-            onCancel: () => {
-                cancelled = true;
-                return false;
-            },
+            onCancel: () => false,
         });
-        if (cancelled) {
+        if (Object.keys(result).length === 0) {
+            cancelled = true;
+        }
+        if (cancelled === true) {
             return {
                 cancelled: true,
             };
@@ -661,9 +695,9 @@ export class CLIUtilityChangelog {
         };
     }
     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)];
+        const adjective = libItemChangelogAdjectives[Math.floor(Math.random() * libItemChangelogAdjectives.length)];
+        const noun = libItemChangelogNouns[Math.floor(Math.random() * libItemChangelogNouns.length)];
+        const verb = libItemChangelogVerbs[Math.floor(Math.random() * libItemChangelogVerbs.length)];
         return `${adjective}-${noun}-${verb}`;
     }
 }