@oneblink/release-cli 2.1.1 → 3.0.0

package/README.md

@@ -1,6 +1,6 @@
 # OneBlink Release CLI [![npm module](https://img.shields.io/npm/v/@oneblink/release-cli.svg)](https://www.npmjs.com/package/@oneblink/release-cli) [![tests](https://github.com/oneblink/release-cli/actions/workflows/test.yml/badge.svg)](https://github.com/oneblink/release-cli/actions)
 
-Used internally by OneBlink to release code bases quickly and consistently
+Used internally by OneBlink to release repositories quickly and consistently
 
 ## CLI Requirements
 

package/dist/bin.js

@@ -2,11 +2,31 @@
 import path from 'path';
 import updateNotifier from 'update-notifier';
 import meow from 'meow';
-import enquirer from 'enquirer';
-import startReleaseProcess from './startReleaseProcess.js';
+import chalk from 'chalk';
+import startRepositoryRelease from './startRepositoryRelease.js';
 import semver from 'semver';
+import promptForNextVersion from './promptForNextVersion.js';
+import getPreRelease from './getPreRelease.js';
+import startProductRelease from './startProductRelease.js';
+import promptForReleaseName from './promptForReleaseName.js';
+import getRepositoryPlugin from './repositories-plugins/plugins-factory.js';
 const cli = meow(`
-oneblink-release [next-version] [--no-git] [--name] [--no-name] [--cwd path]
+${chalk.bold.blue('oneblink-release product [--name]')}
+
+${chalk.grey(`Release each repository in the Product. Each repository will offer prompts for
+the information required to perform the release.`)}
+
+  --name ......... Skip the question to enter a name for the release by passing
+                   a release name as a flag.
+
+${chalk.bold('Examples')}
+
+  oneblink-release product
+  oneblink-release product --name="Inappropriate Release Name"
+
+${chalk.bold.blue('oneblink-release repository [next-version] [--no-git] [--name] [--no-name] [--cwd path]')}
+
+${chalk.grey('Release a single repository.')}
 
   next-version ..... The next version, will prompt for this if not supplied,
                      must be a valid semver number.
@@ -19,18 +39,18 @@ oneblink-release [next-version] [--no-git] [--name] [--no-name] [--cwd path]
     --no-name ...... Skip the question to enter a name for the release. Use
                      option when running a release for an open source repository.
 
-    --cwd .......... Directory of the code base to release relative to the
+    --cwd .......... Directory of the repository to release relative to the
                      current working directory, defaults to the current
                      working directory.
 
-Examples
+${chalk.bold('Examples')}
 
-  oneblink-release
-  oneblink-release --no-name
-  oneblink-release --name="Inappropriate Release Name"
-  oneblink-release 1.1.1
-  oneblink-release 1.1.1 --cwd ../path/to/code
-  oneblink-release 1.1.1-uat.1 --no-git
+  oneblink-release repository
+  oneblink-release repository --no-name
+  oneblink-release repository --name="Inappropriate Release Name"
+  oneblink-release repository 1.1.1
+  oneblink-release repository 1.1.1 --cwd ../path/to/code
+  oneblink-release repository 1.1.1-uat.1 --no-git
 `, {
     importMeta: import.meta,
     flags: {
@@ -67,14 +87,7 @@ async function getReleaseName({ name, preRelease, }) {
     if (typeof name === 'boolean' && !name) {
         return undefined;
     }
-    const { releaseName } = await enquirer.prompt([
-        {
-            type: 'input',
-            message: 'Release name? i.e. JIRA release',
-            name: 'releaseName',
-        },
-    ]);
-    return releaseName;
+    return await promptForReleaseName();
 }
 updateNotifier({
     // @ts-expect-error difference in types between packages
@@ -85,38 +98,44 @@ run().catch((error) => {
     console.error(error);
 });
 async function run() {
-    let input = cli.input[0];
-    if (!input) {
-        const { nextVersion } = await enquirer.prompt([
-            {
-                type: 'input',
-                message: 'Next version? e.g. "1.2.3" or "1.2.3-beta.1"',
-                name: 'nextVersion',
-                required: true,
-                validate: (value) => {
-                    const nextSemverVersion = semver.valid(value);
-                    if (!nextSemverVersion) {
-                        return 'Next version must be valid semver';
-                    }
-                    return true;
-                },
-            },
-        ]);
-        input = nextVersion;
+    const command = cli.input[0];
+    switch (command) {
+        case 'product': {
+            const releaseName = cli.flags.name || (await promptForReleaseName());
+            await startProductRelease({ releaseName });
+            break;
+        }
+        case 'repository': {
+            let input = cli.input[1];
+            const repositoryPlugin = await getRepositoryPlugin({
+                cwd: path.resolve(process.cwd(), cli.flags.cwd),
+            });
+            if (!semver.valid(input)) {
+                const { nextVersion } = await promptForNextVersion({
+                    repositoryPlugin,
+                    noPreRelease: false,
+                });
+                input = nextVersion;
+            }
+            const preRelease = getPreRelease(input)?.tag;
+            const releaseName = await getReleaseName({
+                name: cli.flags.name,
+                preRelease,
+            });
+            await startRepositoryRelease({
+                nextVersion: input,
+                git: cli.flags.git,
+                releaseName,
+                repositoryPlugin,
+            });
+            break;
+        }
+        case undefined: {
+            cli.showHelp();
+            break;
+        }
+        default: {
+            throw new Error(`"${command}" is not a valid command. Please use the "--help" flag to view available commands.`);
+        }
     }
-    const preReleaseComponents = semver.prerelease(input);
-    const preRelease = typeof preReleaseComponents?.[0] === 'string'
-        ? preReleaseComponents[0]
-        : undefined;
-    const releaseName = await getReleaseName({
-        name: cli.flags.name,
-        preRelease,
-    });
-    await startReleaseProcess({
-        preRelease,
-        nextVersion: input,
-        git: cli.flags.git,
-        releaseName,
-        cwd: path.resolve(process.cwd(), cli.flags.cwd),
-    });
 }

package/dist/executeCommand.js

@@ -0,0 +1,15 @@
+import { execa } from 'execa';
+import wrapWithLoading from './wrapWithLoading.js';
+export default async function executeCommand(command, args, cwd) {
+    const log = `"${command} ${args.join(' ')}"`;
+    return await wrapWithLoading({
+        startText: `Running ${log}`,
+        failText: `Failed to run ${log}`,
+    }, async (spinner) => {
+        const result = await execa(command, args, {
+            cwd,
+        });
+        spinner.succeed(`Ran ${log}`);
+        return result;
+    });
+}

package/dist/getPreRelease.js

@@ -0,0 +1,10 @@
+import semver from 'semver';
+export default function getPreRelease(nextVersion) {
+    const [tag, version] = semver.prerelease(nextVersion) || [];
+    return typeof tag === 'string' && typeof version === 'number'
+        ? {
+            tag,
+            version,
+        }
+        : undefined;
+}

package/dist/parseChangelogWithLoading.js

@@ -0,0 +1,15 @@
+import path from 'path';
+import parseChangelog from 'changelog-parser';
+import wrapWithLoading from './wrapWithLoading.js';
+export default async function parseChangelogWithLoading(cwd) {
+    const changelogPath = path.join(cwd, 'CHANGELOG.md');
+    const parsedChangelog = await wrapWithLoading({
+        startText: `Parsing ${changelogPath}`,
+        failText: `Failed to parsed ${changelogPath}`,
+    }, async (spinner) => {
+        const parsedChangelog = await parseChangelog(changelogPath);
+        spinner.succeed(`Parsed ${changelogPath}`);
+        return parsedChangelog;
+    });
+    return { parsedChangelog, changelogPath };
+}

package/dist/promptForNextVersion.js

@@ -0,0 +1,36 @@
+import enquirer from 'enquirer';
+import semver from 'semver';
+import getPreRelease from './getPreRelease.js';
+export default async function promptForNextVersion({ repositoryPlugin, noPreRelease, }) {
+    const currentVersion = await repositoryPlugin.getCurrentVersion();
+    const currentSemverVersion = semver.parse(currentVersion);
+    if (!currentSemverVersion) {
+        throw new Error(`Could not determine current version for ${repositoryPlugin.displayType} repository: ${repositoryPlugin.cwd}`);
+    }
+    const autoIncrementVersion = await repositoryPlugin.autoIncrementVersion?.(currentSemverVersion);
+    if (autoIncrementVersion) {
+        return {
+            nextVersion: autoIncrementVersion,
+        };
+    }
+    return await enquirer.prompt({
+        type: 'input',
+        message: 'Next version? e.g. "1.2.3" or "1.2.3-beta.1"',
+        name: 'nextVersion',
+        required: true,
+        initial: currentVersion,
+        validate: (value) => {
+            if (value === currentVersion) {
+                return `Next version must be different to the current version (${currentVersion})`;
+            }
+            const nextSemverVersion = semver.valid(value);
+            if (!nextSemverVersion) {
+                return 'Next version must be valid semver';
+            }
+            if (noPreRelease && getPreRelease(value)) {
+                return 'Next version must not be a prerelease version';
+            }
+            return true;
+        },
+    });
+}

package/dist/promptForReleaseName.js

@@ -0,0 +1,12 @@
+import enquirer from 'enquirer';
+export default async function promptForReleaseName() {
+    const { releaseName } = await enquirer.prompt([
+        {
+            type: 'input',
+            message: 'Release name? i.e. JIRA release',
+            name: 'releaseName',
+            required: true,
+        },
+    ]);
+    return releaseName;
+}

package/dist/repositories-plugins/CdnHostingPlugin.js

@@ -0,0 +1,5 @@
+import NpmPlugin from './NpmPlugin.js';
+export default class CdnHostingPlugin extends NpmPlugin {
+    displayType = 'CDN Hosting';
+    isDeploymentRequired = true;
+}

package/dist/repositories-plugins/NodeJsPlugin.js

@@ -0,0 +1,12 @@
+import NpmPlugin from './NpmPlugin.js';
+export default class NodeJsPlugin extends NpmPlugin {
+    displayType = 'NodeJS';
+    isDeploymentRequired = true;
+    async autoIncrementVersion(currentSemverVersion) {
+        // NodeJS repositories that are not being published to NPM
+        // don't need to follow semantic versioning as no user ever
+        // gets the option to choose a version. We will simply increment
+        // the existing version by a minor version.
+        return currentSemverVersion.inc('minor').version;
+    }
+}

package/dist/repositories-plugins/NpmPlugin.js

@@ -0,0 +1,42 @@
+import { readPackageUp } from 'read-package-up';
+import { main as packageDiffSummary } from '../package-diff-summary/index.js';
+import executeCommand from '../executeCommand.js';
+export default class NpmPlugin {
+    displayType = 'NPM';
+    isDeploymentRequired = false;
+    cwd;
+    constructor({ cwd }) {
+        this.cwd = cwd;
+    }
+    async getCurrentVersion() {
+        const result = await readPackageUp({
+            cwd: this.cwd,
+        });
+        return result?.packageJson.version;
+    }
+    async incrementVersion(nextSemverVersion) {
+        await executeCommand('npm', ['version', nextSemverVersion.version, '--no-git-tag-version'], this.cwd);
+    }
+    async generateDependenciesChangelog({ previousVersion, }) {
+        try {
+            const entries = await packageDiffSummary({
+                cwd: this.cwd,
+                previousVersion,
+            });
+            return {
+                result: 'ENTRIES',
+                entries,
+            };
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                error.message.includes(`git show ${previousVersion}:package.json`)) {
+                return {
+                    result: 'WARNING',
+                    message: `Skipping inserting the "Dependencies" heading in CHANGELOG.md as it relies on the last release's git tag having a "v" prefix (i.e. "${previousVersion}")`,
+                };
+            }
+            throw error;
+        }
+    }
+}

package/dist/repositories-plugins/NugetPlugin.js

@@ -0,0 +1,28 @@
+import { readFile, writeFile } from 'fs/promises';
+import path from 'path';
+import getPreRelease from '../getPreRelease.js';
+export default class NugetPlugin {
+    isDeploymentRequired = false;
+    displayType = 'Nuget';
+    cwd;
+    relativeProjectFile;
+    constructor({ cwd, relativeProjectFile, }) {
+        this.cwd = cwd;
+        this.relativeProjectFile = relativeProjectFile;
+    }
+    async getCurrentVersion() {
+        const projectFile = path.join(this.cwd, this.relativeProjectFile);
+        const file = await readFile(projectFile, 'utf-8');
+        const matches = file.match(/<PackageVersion>(.*)<\/PackageVersion>/);
+        return matches?.[1];
+    }
+    async incrementVersion(nextSemverVersion) {
+        const projectFile = path.join(this.cwd, this.relativeProjectFile);
+        const fileContents = await readFile(projectFile, 'utf-8');
+        const preRelease = getPreRelease(nextSemverVersion.version);
+        const newFileContents = fileContents
+            .replace(/<PackageVersion>.*<\/PackageVersion>/, `<PackageVersion>${nextSemverVersion.version}</PackageVersion>`)
+            .replace(/<AssemblyVersion>.*<\/AssemblyVersion>/, `<AssemblyVersion>${nextSemverVersion.major}.${nextSemverVersion.minor}.${nextSemverVersion.patch}.${preRelease?.version ?? 0}</AssemblyVersion>`);
+        await writeFile(projectFile, newFileContents, 'utf-8');
+    }
+}

package/dist/repositories-plugins/RepositoryPlugin.js

@@ -0,0 +1 @@
+export {};

package/dist/repositories-plugins/plugins-factory.js

@@ -0,0 +1,54 @@
+import fs from 'fs/promises';
+import path from 'path';
+import NpmPlugin from './NpmPlugin.js';
+import NugetPlugin from './NugetPlugin.js';
+import NodeJsPlugin from './NodeJsPlugin.js';
+import CdnHostingPlugin from './CdnHostingPlugin.js';
+async function exists(filePath) {
+    try {
+        await fs.stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export default async function getRepositoryPlugin({ cwd, repositoryType, }) {
+    switch (repositoryType?.type) {
+        case 'CDN_HOSTING': {
+            return new CdnHostingPlugin({
+                cwd,
+            });
+        }
+        case 'NODE_JS': {
+            return new NodeJsPlugin({
+                cwd,
+            });
+        }
+        case 'NPM': {
+            return new NpmPlugin({
+                cwd,
+            });
+        }
+        case 'NUGET': {
+            return new NugetPlugin({
+                cwd,
+                relativeProjectFile: repositoryType.relativeProjectFile,
+            });
+        }
+    }
+    // If we can't work it out based on type, we will check for certain files.
+    if (await exists(path.join(cwd, 'package.json'))) {
+        return new NpmPlugin({
+            cwd,
+        });
+    }
+    const dotnetSdkProjectFile = path.join('OneBlink.SDK', 'OneBlink.SDK.csproj');
+    if (await exists(path.join(cwd, dotnetSdkProjectFile))) {
+        return new NugetPlugin({
+            cwd,
+            relativeProjectFile: dotnetSdkProjectFile,
+        });
+    }
+    throw new Error(`Could not determine the type of repository: ${cwd}`);
+}

package/dist/startProductRelease.js

@@ -0,0 +1,220 @@
+import { mkdtemp, rm } from 'fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import enquirer from 'enquirer';
+import executeCommand from './executeCommand.js';
+import parseChangelogWithLoading from './parseChangelogWithLoading.js';
+import promptForNextVersion from './promptForNextVersion.js';
+import boxen from 'boxen';
+import chalk from 'chalk';
+import wrapWithLoading from './wrapWithLoading.js';
+import startRepositoryRelease from './startRepositoryRelease.js';
+import path from 'path';
+import getRepositoryPlugin from './repositories-plugins/plugins-factory.js';
+const gitCloneRepositories = [
+    {
+        repositoryName: 'apps',
+        type: 'NPM',
+        isPublic: true,
+    },
+    {
+        repositoryName: 'apps-react',
+        type: 'NPM',
+        isPublic: true,
+    },
+    {
+        repositoryName: 'cli',
+        isPublic: true,
+        type: 'NPM',
+    },
+    {
+        repositoryName: 'forms-cdn',
+        isPublic: true,
+        type: 'CDN_HOSTING',
+    },
+    {
+        repositoryName: 'product-api',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-approvals-api',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-approvals-client',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-cognito-hosted-login-css',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-console',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-form-store-client',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-forms-lambda-at-edge-authorisation',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-forms-renderer',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-infrastructure',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-pdf',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-s3-submission-events',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'product-volunteers-client',
+        isPublic: false,
+        type: 'NODE_JS',
+    },
+    {
+        repositoryName: 'sdk-core-js',
+        isPublic: true,
+        type: 'NPM',
+    },
+    {
+        repositoryName: 'sdk-dotnet',
+        isPublic: true,
+        type: 'NUGET',
+        relativeProjectFile: path.join('OneBlink.SDK', 'OneBlink.SDK.csproj'),
+    },
+    {
+        repositoryName: 'sdk-node-js',
+        isPublic: true,
+        type: 'NPM',
+    },
+];
+export default async function startProductRelease({ releaseName, }) {
+    console.log('Beginning Product release process for:', releaseName);
+    const deploymentRequiredUrls = [];
+    for (const gitCloneRepository of gitCloneRepositories) {
+        const { repositoryName } = gitCloneRepository;
+        const repositoryWorkingDirectory = await wrapWithLoading({
+            startText: `Creating temporary directory to clone "${repositoryName}"`,
+            failText: `Failed to create temporary directory to clone "${repositoryName}"`,
+        }, async (spinner) => {
+            const directory = await mkdtemp(join(tmpdir(), repositoryName));
+            spinner.succeed(`Created temporary directory to clone "${repositoryName}"`);
+            return directory;
+        });
+        try {
+            const cloneUrl = `git@github.com:oneblink/${repositoryName}.git`;
+            await executeCommand('git', ['clone', cloneUrl, repositoryWorkingDirectory], '.');
+            // Check if repository needs releasing
+            const { parsedChangelog } = await parseChangelogWithLoading(repositoryWorkingDirectory);
+            const unreleasedVersion = parsedChangelog.versions.find((version) => version.title.toLowerCase().includes('unreleased'));
+            if (!unreleasedVersion) {
+                await continuePromptWithWarning(`"${repositoryName}" CHANGELOG.md does not contain an "Unreleased" section
+
+You need to checkout "${cloneUrl}" to fix this before trying again.`);
+                continue;
+            }
+            const { stdout: lastCommitMessage } = await executeCommand('git', ['log', '-1', '--pretty=oneline'], repositoryWorkingDirectory);
+            const unreleasedChangelogEntries = unreleasedVersion.body.trim() ||
+                chalk.italic('There are no entries under the "Unreleased" heading.');
+            console.log(boxen(chalk.blue(`${unreleasedChangelogEntries}
+          
+Last Commit: ${lastCommitMessage}`), {
+                title: 'Unreleased Entries',
+                padding: 1,
+                margin: {
+                    top: 1,
+                    bottom: 1,
+                },
+            }));
+            const { isReleasing } = await enquirer.prompt({
+                type: 'select',
+                name: 'isReleasing',
+                message: `Would you like to release "${repositoryName}"? See unreleased section from changelog above to decide.`,
+                choices: [
+                    {
+                        message: `No! "${repositoryName}" does not need to be released.`,
+                        name: 'no',
+                    },
+                    {
+                        message: 'Yes, release away!',
+                        name: 'yes',
+                    },
+                ],
+            });
+            if (isReleasing === 'no') {
+                continue;
+            }
+            const repositoryPlugin = await getRepositoryPlugin({
+                cwd: repositoryWorkingDirectory,
+                repositoryType: gitCloneRepository,
+            });
+            const { nextVersion } = await promptForNextVersion({
+                repositoryPlugin,
+                noPreRelease: true,
+            });
+            await startRepositoryRelease({
+                nextVersion,
+                git: true,
+                releaseName: gitCloneRepository.isPublic ? undefined : releaseName,
+                repositoryPlugin,
+            });
+            if (repositoryPlugin.isDeploymentRequired) {
+                deploymentRequiredUrls.push(`https://github.com/oneblink/${repositoryName}/actions`);
+            }
+        }
+        finally {
+            await wrapWithLoading({
+                startText: `Removing temporary directory for "${repositoryName}"`,
+                failText: `Failed to remove temporary directory for "${repositoryName}"`,
+            }, async (spinner) => {
+                await rm(repositoryWorkingDirectory, {
+                    recursive: true,
+                    force: true,
+                });
+                spinner.succeed(`Removed temporary directory for "${repositoryName}"`);
+            });
+        }
+    }
+    console.log(boxen(chalk.green('Product Release Complete!!!'), {
+        padding: 1,
+    }));
+    if (deploymentRequiredUrls.length) {
+        console.log(boxen(`The following repositories need to be deployed when ready:
+
+  ${deploymentRequiredUrls.join(`
+  `)}`, {
+            padding: 1,
+        }));
+    }
+}
+async function continuePromptWithWarning(warning) {
+    console.log(boxen(chalk.yellow(warning), {
+        padding: 1,
+    }));
+    await enquirer.prompt({
+        type: 'invisible',
+        name: 'continue',
+        message: 'Press ENTER to continue.',
+    });
+}

package/dist/{startReleaseProcess.js → startRepositoryRelease.js}

@@ -1,45 +1,27 @@
 import fs from 'fs';
 import path from 'path';
 import util from 'util';
-import { execa } from 'execa';
 import prettier from 'prettier';
-import parseChangelog from 'changelog-parser';
-import { main as packageDiffSummary } from './package-diff-summary/index.js';
 import semver from 'semver';
 import ora from 'ora';
-import { readPackageUp } from 'read-package-up';
+import wrapWithLoading from './wrapWithLoading.js';
+import executeCommand from './executeCommand.js';
+import parseChangelogWithLoading from './parseChangelogWithLoading.js';
+import getPreRelease from './getPreRelease.js';
 const readFileAsync = util.promisify(fs.readFile);
 const writeFileAsync = util.promisify(fs.writeFile);
 const UNRELEASED_VERSION_INDEX = 0;
 const GIT_TAG_PREFIX = 'v';
-async function wrapWithLoading({ startText, failText }, fn) {
-    const spinner = ora(startText).start();
-    try {
-        const t = await fn(spinner);
-        if (spinner.isSpinning) {
-            spinner.stop();
-        }
-        return t;
-    }
-    catch (error) {
-        spinner.fail(failText);
-        throw error;
-    }
-}
-async function updateChangelog({ nextSemverVersion, cwd, releaseName, }) {
-    const changelogPath = path.join(cwd, 'CHANGELOG.md');
-    const parsedChangelog = await wrapWithLoading({
-        startText: `Parsing ${changelogPath}`,
-        failText: `Failed to parsed ${changelogPath}`,
-    }, async (spinner) => {
-        const parsedChangelog = (await parseChangelog(changelogPath));
-        spinner.succeed(`Parsed ${changelogPath}`);
-        return parsedChangelog;
-    });
+async function updateChangelog({ nextSemverVersion, releaseName, repositoryPlugin, }) {
+    const { parsedChangelog, changelogPath } = await parseChangelogWithLoading(repositoryPlugin.cwd);
     const dependenciesChangelogEntry = await wrapWithLoading({
         startText: 'Checking if the "Dependencies" heading should be added to CHANGELOG.md',
         failText: 'Failed to check if the "Dependencies" heading should be added to CHANGELOG.md',
     }, async (spinner) => {
+        if (!repositoryPlugin.generateDependenciesChangelog) {
+            spinner.info(`Evaluating "Dependencies" is not supported for ${repositoryPlugin.displayType} repositories.`);
+            return '';
+        }
         const unreleasedVersion = parsedChangelog.versions[UNRELEASED_VERSION_INDEX];
         if (!unreleasedVersion ||
             !unreleasedVersion.title.toLowerCase().includes('unreleased')) {
@@ -55,25 +37,15 @@ async function updateChangelog({ nextSemverVersion, cwd, releaseName, }) {
             spinner.info('Skipping inserting the "Dependencies" heading in CHANGELOG.md as this is the first release according to the CHANGELOG.md.');
             return '';
         }
-        let dependenciesChangelogEntries = '';
         const lastGitTag = `${GIT_TAG_PREFIX}${lastVersion.version}`;
-        try {
-            const result = await packageDiffSummary({
-                cwd,
-                previousVersion: lastGitTag,
-            });
-            if (result) {
-                dependenciesChangelogEntries = result.trim();
-            }
-        }
-        catch (error) {
-            if (error.message.includes(`git show ${lastGitTag}:package.json`)) {
-                spinner.warn(`Skipping inserting the "Dependencies" heading in CHANGELOG.md as it relies on the last release's git tag having a "v" prefix (i.e. "${lastGitTag}")`);
-                return '';
-            }
-            throw error;
+        const dependenciesChangelog = await repositoryPlugin.generateDependenciesChangelog({
+            previousVersion: lastGitTag,
+        });
+        if (dependenciesChangelog.result === 'WARNING') {
+            spinner.warn(dependenciesChangelog.message);
+            return '';
         }
-        if (!dependenciesChangelogEntries) {
+        if (!dependenciesChangelog.entries?.trim()) {
             spinner.info(`Skipping inserting the "Dependencies" heading in CHANGELOG.md as there were no dependency changes since the last release (${lastVersion.version})`);
             return '';
         }
@@ -81,10 +53,10 @@ async function updateChangelog({ nextSemverVersion, cwd, releaseName, }) {
         return `
 ${dependenciesChangelogHeading}
 
-${dependenciesChangelogEntries}
+${dependenciesChangelog.entries}
 `;
     });
-    const nextReleaseTitle = `[${nextSemverVersion}] - ${new Date()
+    const nextReleaseTitle = `[${nextSemverVersion.version}] - ${new Date()
         .toISOString()
         .substring(0, 10)}`;
     const releaseNameSubtitle = releaseName
@@ -98,7 +70,7 @@ ${dependenciesChangelogEntries}
     }, async (spinner) => {
         let prettierOptions = {};
         try {
-            const s = await readFileAsync(path.join(cwd, '.prettierrc'), 'utf-8');
+            const s = await readFileAsync(path.join(repositoryPlugin.cwd, '.prettierrc'), 'utf-8');
             prettierOptions = JSON.parse(s);
         }
         catch (error) {
@@ -136,52 +108,39 @@ ${body}
         spinner.succeed(`Updated CHANGELOG.md with next release (${nextReleaseTitle})`);
     });
 }
-async function checkIfNPMPackageVersionShouldBeUpdated(cwd) {
-    const result = await readPackageUp({
-        cwd,
-    });
-    return !!result?.packageJson;
-}
-async function executeCommand(command, args, cwd) {
-    await wrapWithLoading({
-        startText: `Running "${command} ${args.join(' ')}"`,
-        failText: `Failed to run "${command} ${args.join(' ')}"`,
-    }, async (spinner) => {
-        await execa(command, args, {
-            cwd,
-        });
-        spinner.succeed(`Ran "${command} ${args.join(' ')}"`);
-    });
-}
-export default async function startReleaseProcess({ nextVersion, preRelease, cwd, git, releaseName, }) {
-    const nextSemverVersion = semver.valid(nextVersion);
+export default async function startRepositoryRelease({ nextVersion, git, releaseName, repositoryPlugin, }) {
+    const nextSemverVersion = semver.parse(nextVersion);
     if (!nextSemverVersion) {
         throw new Error('Next version is not valid semver');
     }
-    const npm = await checkIfNPMPackageVersionShouldBeUpdated(cwd);
+    const preRelease = getPreRelease(nextVersion);
     if (preRelease) {
-        const text = `Skipping changelog updates for "${preRelease}" release`;
+        const text = `Skipping changelog updates for "${preRelease.tag}" release`;
         ora(text).start().info(text);
     }
     else {
         await updateChangelog({
             nextSemverVersion,
-            cwd,
             releaseName,
+            repositoryPlugin,
         });
     }
-    if (npm) {
-        await executeCommand('npm', ['version', nextSemverVersion, '--no-git-tag-version'], cwd);
-    }
+    await repositoryPlugin.incrementVersion(nextSemverVersion);
     if (!git) {
         const text = `Skipping committing release changes using git`;
         ora(text).start().info(text);
         return;
     }
-    const message = `[RELEASE] ${nextSemverVersion}${releaseName ? ` - ${releaseName}` : ''}`;
-    await executeCommand('git', ['add', '-A'], cwd);
-    await executeCommand('git', ['commit', '--message', message], cwd);
-    await executeCommand('git', ['push'], cwd);
-    await executeCommand('git', ['tag', '-a', `${GIT_TAG_PREFIX}${nextSemverVersion}`, '-m', message], cwd);
-    await executeCommand('git', ['push', '--tags'], cwd);
+    const message = `[RELEASE] ${nextSemverVersion.version}${releaseName ? ` - ${releaseName}` : ''}`;
+    await executeCommand('git', ['add', '-A'], repositoryPlugin.cwd);
+    await executeCommand('git', ['commit', '--message', message], repositoryPlugin.cwd);
+    await executeCommand('git', ['push'], repositoryPlugin.cwd);
+    await executeCommand('git', [
+        'tag',
+        '-a',
+        `${GIT_TAG_PREFIX}${nextSemverVersion.version}`,
+        '-m',
+        message,
+    ], repositoryPlugin.cwd);
+    await executeCommand('git', ['push', '--tags'], repositoryPlugin.cwd);
 }

package/dist/wrapWithLoading.js

@@ -0,0 +1,15 @@
+import ora from 'ora';
+export default async function wrapWithLoading({ startText, failText }, fn) {
+    const spinner = ora(startText).start();
+    try {
+        const t = await fn(spinner);
+        if (spinner.isSpinning) {
+            spinner.stop();
+        }
+        return t;
+    }
+    catch (error) {
+        spinner.fail(failText);
+        throw error;
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oneblink/release-cli",
-  "description": "Used internally by OneBlink to release code bases quickly and consistently",
-  "version": "2.1.1",
+  "description": "Used internally by OneBlink to release repositories quickly and consistently",
+  "version": "3.0.0",
   "author": "OneBlink <developers@oneblink> (https://github.com/oneblink)",
   "bin": {
     "oneblink-release": "dist/bin.js"
@@ -9,8 +9,13 @@
   "bugs": {
     "url": "https://github.com/oneblink/release-cli/issues"
   },
+  "bundleDependencies": [
+    "changelog-parser"
+  ],
   "dependencies": {
     "@octokit/rest": "^20.0.2",
+    "boxen": "^7.1.1",
+    "chalk": "^5.3.0",
     "changelog-parser": "^3.0.1",
     "dependency-diff": "^1.0.4",
     "enquirer": "^2.4.1",
@@ -24,9 +29,6 @@
     "semver": "^7.5.4",
     "update-notifier": "^7.0.0"
   },
-  "bundleDependencies": [
-    "changelog-parser"
-  ],
   "devDependencies": {
     "@types/changelog-parser": "^2.8.3",
     "@types/github-url-from-git": "^1.5.2",
@@ -72,12 +74,13 @@
     "build": "tsc --build",
     "eslint": "eslint --fix --cache --quiet ./src",
     "jest": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --silent",
+    "postinstall": "patch-package",
     "prepare": "npm run build",
+    "prerelease": "npm run build",
     "pretest": "npm run eslint",
+    "release": "./dist/bin.js repository --no-name --cwd .",
     "test": "npm run jest",
-    "postinstall": "patch-package",
-    "prerelease": "npm run build",
-    "release": "./dist/bin.js --no-name --cwd ."
+    "typescript": "tsc --noEmit"
   },
   "type": "module"
 }