diff --git a/packages/create-release-branch/package.json b/packages/create-release-branch/package.json index 7dfd2ad..e6ac972 100644 --- a/packages/create-release-branch/package.json +++ b/packages/create-release-branch/package.json @@ -44,7 +44,11 @@ "test:watch": "vitest --watch" }, "dependencies": { + "@changesets/config": "^4.0.1", + "@changesets/get-release-plan": "^5.0.2", + "@changesets/types": "^7.0.0", "@clack/prompts": "^1.8.1", + "@manypkg/get-packages": "^3.1.0", "@metamask/action-utils": "^2.0.0", "@metamask/auto-changelog": "^7.1.0", "@metamask/utils": "^11.12.0", diff --git a/packages/create-release-branch/src/core/candidates.ts b/packages/create-release-branch/src/core/candidates.ts index c4909cc..1c3f3e6 100644 --- a/packages/create-release-branch/src/core/candidates.ts +++ b/packages/create-release-branch/src/core/candidates.ts @@ -1,6 +1,6 @@ /** - * Why a package is offered for release: it has changes, it depends on a - * package that is being released, or it has entries in its changelog. + * Why a package is offered for release: it has changes, or it depends on a + * package that is being released. */ export type CandidateKind = /** @@ -11,13 +11,7 @@ export type CandidateKind = /** * The package is released only because one of its dependencies is released. */ - | 'dependency' - /** - * Changesets mode only: the package has no changesets, but its changelog has - * hand-written entries in its Unreleased section (during the migration to - * Changesets). - */ - | 'legacy-entries'; + | 'dependency'; /** * A package that the maintainer can choose to include in the release. diff --git a/packages/create-release-branch/src/core/release-steps.test.ts b/packages/create-release-branch/src/core/release-steps.test.ts index af403e0..446e043 100644 --- a/packages/create-release-branch/src/core/release-steps.test.ts +++ b/packages/create-release-branch/src/core/release-steps.test.ts @@ -387,26 +387,23 @@ describe('release-steps', () => { }); }); - it('passes only changes and legacy-entries candidates as packages with changes', async () => { + it('passes only changes candidates as packages with changes', async () => { const project = buildMockProject({ workspacePackages: { a: buildMockPackage('a', '1.0.0', { validatedManifest: { dependencies: { changed: '1.0.0', dependent: '1.0.0' }, - peerDependencies: { legacy: '1.0.0' }, }, }), changed: buildMockPackage('changed', '1.0.0'), dependent: buildMockPackage('dependent', '1.0.0', { hasChangesSinceLatestRelease: true, }), - legacy: buildMockPackage('legacy', '1.0.0'), }, }); const candidates: Candidate[] = [ { name: 'changed', currentVersion: '1.0.0', kind: 'changes' }, { name: 'dependent', currentVersion: '1.0.0', kind: 'dependency' }, - { name: 'legacy', currentVersion: '1.0.0', kind: 'legacy-entries' }, ]; const plan = vi.fn(); const mode = buildMockMode({ @@ -424,7 +421,7 @@ describe('release-steps', () => { a: { missingDirectDependentNames: [], missingPeerDependentNames: [], - missingDependencies: ['changed', 'legacy'], + missingDependencies: ['changed'], }, }); expect(plan).not.toHaveBeenCalled(); diff --git a/packages/create-release-branch/src/core/release-steps.ts b/packages/create-release-branch/src/core/release-steps.ts index 14ef9dd..185acd2 100644 --- a/packages/create-release-branch/src/core/release-steps.ts +++ b/packages/create-release-branch/src/core/release-steps.ts @@ -132,9 +132,7 @@ export async function checkChoices({ }): Promise> { const candidates = await mode.listCandidates(choices); const packagesWithChanges = new Set( - candidates - .filter(({ kind }) => kind === 'changes' || kind === 'legacy-entries') - .map(({ name }) => name), + candidates.filter(({ kind }) => kind === 'changes').map(({ name }) => name), ); const { errors, dependencyFindings } = checkReleaseChoices(project, choices, { diff --git a/packages/create-release-branch/src/modes/changesets/candidates.test.ts b/packages/create-release-branch/src/modes/changesets/candidates.test.ts new file mode 100644 index 0000000..7b59999 --- /dev/null +++ b/packages/create-release-branch/src/modes/changesets/candidates.test.ts @@ -0,0 +1,180 @@ +import { describe, expect, it } from 'vitest'; + +import { + buildMockChangesetsState, + buildMockPackage, + buildMockProject, +} from '../../../tests/unit/helpers.js'; +import { compareNames, listChangesetsCandidates } from './candidates.js'; + +describe('candidates', () => { + describe('listChangesetsCandidates', () => { + it('lists the packages with changes, then with a dependency bump, each sorted by name', () => { + const project = buildMockProject({ + workspacePackages: { + '@scope/b': buildMockPackage('@scope/b', '1.0.0'), + '@scope/a': buildMockPackage('@scope/a', '1.0.0'), + '@scope/c': buildMockPackage('@scope/c', '1.0.0'), + '@scope/z': buildMockPackage('@scope/z', '1.0.0'), + }, + }); + const state = buildMockChangesetsState({ + fullPlan: { + changesets: [ + { + id: 'brave-cats-sing', + summary: '', + releases: [{ name: '@scope/b', type: 'major' }], + }, + { + id: 'calm-dogs-run', + summary: '', + releases: [ + { name: '@scope/a', type: 'patch' }, + { name: '@scope/b', type: 'patch' }, + ], + }, + { + id: 'eager-owls-fly', + summary: '', + releases: [{ name: '@scope/a', type: 'patch' }], + }, + ], + releases: [ + { + name: '@scope/z', + type: 'patch', + oldVersion: '1.0.0', + newVersion: '1.0.1', + changesets: [], + }, + { + name: '@scope/b', + type: 'major', + oldVersion: '1.0.0', + newVersion: '2.0.0', + changesets: ['brave-cats-sing', 'calm-dogs-run'], + }, + { + name: '@scope/c', + type: 'patch', + oldVersion: '1.0.0', + newVersion: '1.0.1', + changesets: [], + }, + { + name: '@scope/a', + type: 'patch', + oldVersion: '1.0.0', + newVersion: '1.0.1', + changesets: ['calm-dogs-run', 'eager-owls-fly'], + }, + ], + preState: undefined, + }, + }); + + expect(listChangesetsCandidates(project, state)).toStrictEqual([ + { + name: '@scope/a', + currentVersion: '1.0.0', + plannedVersion: '1.0.1', + kind: 'changes', + changeCount: 2, + }, + { + name: '@scope/b', + currentVersion: '1.0.0', + plannedVersion: '2.0.0', + kind: 'changes', + changeCount: 2, + }, + { + name: '@scope/c', + currentVersion: '1.0.0', + plannedVersion: '1.0.1', + kind: 'dependency', + }, + { + name: '@scope/z', + currentVersion: '1.0.0', + plannedVersion: '1.0.1', + kind: 'dependency', + }, + ]); + }); + + it('does not list or count a release of type "none"', () => { + const project = buildMockProject({ + workspacePackages: { + '@scope/a': buildMockPackage('@scope/a', '1.0.0'), + '@scope/b': buildMockPackage('@scope/b', '1.0.0'), + }, + }); + const state = buildMockChangesetsState({ + fullPlan: { + changesets: [ + { + id: 'brave-cats-sing', + summary: '', + releases: [ + { name: '@scope/a', type: 'none' }, + { name: '@scope/b', type: 'patch' }, + ], + }, + ], + releases: [ + { + name: '@scope/a', + type: 'none', + oldVersion: '1.0.0', + newVersion: '1.0.0', + changesets: ['brave-cats-sing'], + }, + { + name: '@scope/b', + type: 'patch', + oldVersion: '1.0.0', + newVersion: '1.0.1', + changesets: ['brave-cats-sing'], + }, + ], + preState: undefined, + }, + }); + + expect(listChangesetsCandidates(project, state)).toStrictEqual([ + { + name: '@scope/b', + currentVersion: '1.0.0', + plannedVersion: '1.0.1', + kind: 'changes', + changeCount: 1, + }, + ]); + }); + + it('lists no package when there are no pending Changesets', () => { + const project = buildMockProject({ + workspacePackages: { + '@scope/a': buildMockPackage('@scope/a', '1.0.0'), + }, + }); + + expect( + listChangesetsCandidates(project, buildMockChangesetsState()), + ).toStrictEqual([]); + }); + }); + + describe('compareNames', () => { + it('orders names by code unit', () => { + expect(['b', 'B', 'a', 'a'].sort(compareNames)).toStrictEqual([ + 'B', + 'a', + 'a', + 'b', + ]); + }); + }); +}); diff --git a/packages/create-release-branch/src/modes/changesets/candidates.ts b/packages/create-release-branch/src/modes/changesets/candidates.ts new file mode 100644 index 0000000..1453fb1 --- /dev/null +++ b/packages/create-release-branch/src/modes/changesets/candidates.ts @@ -0,0 +1,78 @@ +import type { ComprehensiveRelease } from '@changesets/types'; + +import type { Candidate, CandidateKind } from '../../core/candidates.js'; +import type { Project } from '../../project/project.js'; +import type { ChangesetsState } from './load.js'; + +/** + * A release that bumps the version of its package. + */ +export type BumpingRelease = Exclude; + +const KIND_ORDER: CandidateKind[] = ['changes', 'dependency']; + +/** + * Compares two strings by code unit, whatever the locale. + * + * @param left - The first string. + * @param right - The second string. + * @returns A negative number, zero, or a positive number. + */ +export function compareNames(left: string, right: string): number { + return Number(left > right) - Number(left < right); +} + +/** + * Determines whether a release bumps the version of its package. + * + * @param release - The release. + * @returns Whether the release type is not `none`. + */ +export function isBumpingRelease( + release: ComprehensiveRelease, +): release is BumpingRelease { + return release.type !== 'none'; +} + +/** + * Lists the packages that the full release plan bumps. + * + * @param project - The project. + * @param state - The Changesets state. + * @returns The candidates, grouped by kind and sorted by name. + */ +export function listChangesetsCandidates( + project: Project, + state: ChangesetsState, +): Candidate[] { + return state.fullPlan.releases + .filter(isBumpingRelease) + .map(({ name, newVersion }): Candidate => { + const currentVersion = + project.workspacePackages[name].validatedManifest.version.version; + const changeCount = state.fullPlan.changesets.filter(({ releases }) => + releases.some( + (release) => release.name === name && release.type !== 'none', + ), + ).length; + return changeCount > 0 + ? { + name, + currentVersion, + plannedVersion: newVersion, + kind: 'changes', + changeCount, + } + : { + name, + currentVersion, + plannedVersion: newVersion, + kind: 'dependency', + }; + }) + .sort( + (left, right) => + KIND_ORDER.indexOf(left.kind) - KIND_ORDER.indexOf(right.kind) || + compareNames(left.name, right.name), + ); +} diff --git a/packages/create-release-branch/src/modes/changesets/load.test.ts b/packages/create-release-branch/src/modes/changesets/load.test.ts new file mode 100644 index 0000000..ad7c7a4 --- /dev/null +++ b/packages/create-release-branch/src/modes/changesets/load.test.ts @@ -0,0 +1,220 @@ +import { defaultConfig, readConfig } from '@changesets/config'; +import { getReleasePlan } from '@changesets/get-release-plan'; +import type { Config } from '@changesets/types'; +import { getPackages } from '@manypkg/get-packages'; +import { describe, expect, it, vi } from 'vitest'; + +import { buildMockChangesetsState } from '../../../tests/unit/helpers.js'; +import { + CHANGELOG_MODULE, + ChangesetsSetupError, + loadChangesets, +} from './load.js'; +import type { ChangesetsState } from './load.js'; + +vi.mock(import('@changesets/config'), async (importActual) => ({ + ...(await importActual()), + readConfig: vi.fn(), +})); +vi.mock('@changesets/get-release-plan'); +vi.mock('@manypkg/get-packages'); + +const CONFIG_PATH = '/path/to/project/.changeset/config.json'; + +const CONFIG: Config = { + ...defaultConfig, + changelog: [CHANGELOG_MODULE, { repository: 'example-org/example-repo' }], +}; + +const format = { + name: (text: string): string => `<${text}>`, + dim: (text: string): string => `(${text})`, +}; + +/** + * Mocks what Changesets reads from the project. + * + * @param overrides - The parts of the state to change. + * @returns The mocked state. + */ +function mockChangesetsState( + overrides: Partial = {}, +): ChangesetsState { + const state = buildMockChangesetsState({ config: CONFIG, ...overrides }); + vi.mocked(getPackages).mockResolvedValue( + state.packages as Awaited>, + ); + vi.mocked(readConfig).mockResolvedValue({ + config: state.config, + warnings: [], + errors: undefined, + }); + vi.mocked(getReleasePlan).mockResolvedValue(state.fullPlan); + return state; +} + +describe('load', () => { + describe('loadChangesets', () => { + it('reads the packages, the configuration, and the release plan of all pending Changesets', async () => { + const state = mockChangesetsState({ + fullPlan: { + changesets: [ + { + id: 'brave-cats-sing', + summary: 'Add a feature', + releases: [{ name: '@scope/a', type: 'minor' }], + }, + ], + releases: [ + { + name: '@scope/a', + type: 'minor', + oldVersion: '1.0.0', + newVersion: '1.1.0', + changesets: ['brave-cats-sing'], + }, + ], + preState: undefined, + }, + }); + + expect(await loadChangesets('/path/to/project')).toStrictEqual(state); + expect(readConfig).toHaveBeenCalledWith( + '/path/to/project', + state.packages, + ); + expect(getReleasePlan).toHaveBeenCalledWith( + '/path/to/project', + undefined, + state.config, + ); + }); + + it('accepts a project that is exiting Changesets pre mode', async () => { + mockChangesetsState({ + fullPlan: { + changesets: [], + releases: [], + preState: { mode: 'exit', tag: 'beta' }, + }, + }); + + const { fullPlan } = await loadChangesets('/path/to/project'); + + expect(fullPlan.preState?.mode).toBe('exit'); + }); + + it('throws a setup error if the project has no Changesets configuration', async () => { + mockChangesetsState(); + const cause = Object.assign(new Error('Not found'), { code: 'ENOENT' }); + vi.mocked(readConfig).mockRejectedValue(cause); + + const promise = loadChangesets('/path/to/project'); + + await expect(promise).rejects.toThrow( + new ChangesetsSetupError({ + problem: 'Changesets mode needs a Changesets configuration.', + details: [ + 'Set up Changesets in the project, or release it in legacy mode.', + ], + filePath: CONFIG_PATH, + }), + ); + await expect(promise).rejects.toHaveProperty('cause', cause); + }); + + it('throws other errors from reading the configuration as they are', async () => { + mockChangesetsState(); + const error = new SyntaxError('Unexpected end of JSON input'); + vi.mocked(readConfig).mockRejectedValue(error); + + await expect(loadChangesets('/path/to/project')).rejects.toBe(error); + }); + + it('throws a setup error that lists the problems of a configuration that is not valid', async () => { + mockChangesetsState(); + vi.mocked(readConfig).mockResolvedValue({ + config: undefined, + warnings: [], + errors: ['Problem 1', 'Problem 2'], + }); + + await expect(loadChangesets('/path/to/project')).rejects.toThrow( + new ChangesetsSetupError({ + problem: 'The Changesets configuration is not valid:', + details: ['Problem 1', 'Problem 2'], + filePath: CONFIG_PATH, + }), + ); + }); + + it.each([ + { description: 'no changelog module', changelog: false as const }, + { + description: 'another changelog module', + changelog: ['@changesets/cli/changelog', null] as const, + }, + ])( + 'throws a setup error if the configuration has $description', + async ({ changelog }) => { + mockChangesetsState({ config: { ...CONFIG, changelog } }); + + await expect(loadChangesets('/path/to/project')).rejects.toThrow( + new ChangesetsSetupError({ + problem: + 'Changesets mode needs the @metamask/changesets-changelog changelog module.', + details: [ + 'Set "changelog" to ["@metamask/changesets-changelog", { "repository": "/" }] in the Changesets configuration.', + ], + filePath: CONFIG_PATH, + }), + ); + }, + ); + + it('throws a setup error if the project is in Changesets pre mode', async () => { + mockChangesetsState({ + fullPlan: { + changesets: [], + releases: [], + preState: { mode: 'pre', tag: 'beta' }, + }, + }); + + await expect(loadChangesets('/path/to/project')).rejects.toThrow( + new ChangesetsSetupError({ + problem: 'Changesets pre mode is not supported.', + details: [ + 'Exit pre mode with "changeset pre exit", then run this tool again.', + ], + filePath: '/path/to/project/.changeset/pre.json', + }), + ); + }); + }); + + describe('ChangesetsSetupError', () => { + it('describes the problem, the details, then the file path', () => { + const error = new ChangesetsSetupError({ + problem: 'Some problem.', + details: ['Some detail.'], + filePath: '/some/file', + }); + + expect(error.describe(format)).toStrictEqual({ + title: 'Some problem.', + lines: ['Some detail.', '(/some/file)'], + }); + expect(error.message).toBe('Some problem.\nSome detail.\n/some/file'); + }); + + it('has no file path line if there is no file path', () => { + const error = new ChangesetsSetupError({ + problem: 'Some problem.', + details: ['Some detail.'], + }); + + expect(error.message).toBe('Some problem.\nSome detail.'); + }); + }); +}); diff --git a/packages/create-release-branch/src/modes/changesets/load.ts b/packages/create-release-branch/src/modes/changesets/load.ts new file mode 100644 index 0000000..3de49de --- /dev/null +++ b/packages/create-release-branch/src/modes/changesets/load.ts @@ -0,0 +1,161 @@ +import { readConfig } from '@changesets/config'; +import { getReleasePlan } from '@changesets/get-release-plan'; +import type { Config, Packages, ReleasePlan } from '@changesets/types'; +import { getPackages } from '@manypkg/get-packages'; +import path from 'path'; + +import type { CliOutput } from '../../core/cli-output.js'; +import type { ErrorDescription } from '../../core/user-facing-error.js'; +import { UserFacingError } from '../../core/user-facing-error.js'; +import { isErrorWithCode } from '../../utils/misc-utils.js'; + +/** + * The changelog module that Changesets mode requires. + */ +export const CHANGELOG_MODULE = '@metamask/changesets-changelog'; + +/** + * The workspace packages, the Changesets configuration, and the release plan + * of all pending Changesets. + */ +export type ChangesetsState = { + packages: Packages; + config: Config; + fullPlan: ReleasePlan; +}; + +/** + * A problem that stops Changesets mode before it writes anything. + */ +export class ChangesetsSetupError extends UserFacingError { + problem: string; + + details: string[]; + + filePath: string | undefined; + + /** + * Creates the error. + * + * @param args - The arguments. + * @param args.problem - What is wrong. + * @param args.details - How to fix it. + * @param args.filePath - The file that has the problem. + * @param options - The options. + * @param options.cause - The error that caused the problem. + */ + constructor( + { + problem, + details, + filePath, + }: { problem: string; details: string[]; filePath?: string }, + options?: { cause: unknown }, + ) { + super(undefined, options); + this.problem = problem; + this.details = details; + this.filePath = filePath; + const plain = (text: string): string => text; + const { title, lines } = this.describe({ name: plain, dim: plain }); + this.message = [title, ...lines].join('\n'); + } + + describe(format: CliOutput['format']): ErrorDescription { + return { + title: this.problem, + lines: + this.filePath === undefined + ? this.details + : [...this.details, format.dim(this.filePath)], + }; + } +} + +/** + * Reads the Changesets configuration, which must use {@link CHANGELOG_MODULE}. + * + * @param projectDirectoryPath - The path to the project root. + * @param packages - The workspace packages. + * @returns The configuration. + */ +async function readChangesetsConfig( + projectDirectoryPath: string, + packages: Packages, +): Promise { + const configPath = path.join( + projectDirectoryPath, + '.changeset', + 'config.json', + ); + + let result: Awaited>; + try { + result = await readConfig(projectDirectoryPath, packages); + } catch (error) { + if (isErrorWithCode(error) && error.code === 'ENOENT') { + throw new ChangesetsSetupError( + { + problem: 'Changesets mode needs a Changesets configuration.', + details: [ + 'Set up Changesets in the project, or release it in legacy mode.', + ], + filePath: configPath, + }, + { cause: error }, + ); + } + throw error; + } + + if (result.errors !== undefined) { + throw new ChangesetsSetupError({ + problem: 'The Changesets configuration is not valid:', + details: result.errors, + filePath: configPath, + }); + } + + const { changelog } = result.config; + if (changelog === false || changelog[0] !== CHANGELOG_MODULE) { + throw new ChangesetsSetupError({ + problem: `Changesets mode needs the ${CHANGELOG_MODULE} changelog module.`, + details: [ + `Set "changelog" to ["${CHANGELOG_MODULE}", { "repository": "/" }] in the Changesets configuration.`, + ], + filePath: configPath, + }); + } + + return result.config; +} + +/** + * Reads the Changesets state of the project. Pre mode is not supported. + * + * @param projectDirectoryPath - The path to the project root. + * @returns The Changesets state. + */ +export async function loadChangesets( + projectDirectoryPath: string, +): Promise { + const packages = await getPackages(projectDirectoryPath); + const config = await readChangesetsConfig(projectDirectoryPath, packages); + const fullPlan = await getReleasePlan( + projectDirectoryPath, + undefined, + config, + ); + + if (fullPlan.preState?.mode === 'pre') { + throw new ChangesetsSetupError({ + problem: 'Changesets pre mode is not supported.', + details: [ + 'Exit pre mode with "changeset pre exit", then run this tool again.', + ], + filePath: path.join(projectDirectoryPath, '.changeset', 'pre.json'), + }); + } + + return { packages, config, fullPlan }; +} diff --git a/packages/create-release-branch/tests/unit/helpers.ts b/packages/create-release-branch/tests/unit/helpers.ts index 20e6f02..71ece44 100644 --- a/packages/create-release-branch/tests/unit/helpers.ts +++ b/packages/create-release-branch/tests/unit/helpers.ts @@ -1,3 +1,4 @@ +import { defaultConfig } from '@changesets/config'; import { isPlainObject } from '@metamask/utils'; import fs from 'fs'; import path from 'path'; @@ -8,6 +9,7 @@ import { vi } from 'vitest'; import { createCliOutput } from '../../src/core/cli-output.js'; import type { CliOutput } from '../../src/core/cli-output.js'; import type { Mode, ModePrepareStep } from '../../src/core/mode.js'; +import type { ChangesetsState } from '../../src/modes/changesets/load.js'; import { PackageManifestDependenciesFieldNames, PackageManifestFieldNames, @@ -141,6 +143,28 @@ export function buildMockPackage( }; } +/** + * Builds a Changesets state for use in tests. All properties have default + * values, so you can specify only the properties you care about. + * + * @param overrides - The properties that will go into the object. + * @returns The mock ChangesetsState. + */ +export function buildMockChangesetsState( + overrides: Partial = {}, +): ChangesetsState { + return { + packages: { + rootDir: '/path/to/project', + packages: [], + tool: { type: 'yarn' }, + }, + config: defaultConfig, + fullPlan: { changesets: [], releases: [], preState: undefined }, + ...overrides, + }; +} + /** * Builds a manifest object for use in tests. All properties have default * values, so you can specify only the properties you care about. diff --git a/yarn.lock b/yarn.lock index 0c5a699..0cbf36f 100644 --- a/yarn.lock +++ b/yarn.lock @@ -358,6 +358,20 @@ __metadata: languageName: node linkType: hard +"@changesets/get-release-plan@npm:^5.0.2": + version: 5.0.2 + resolution: "@changesets/get-release-plan@npm:5.0.2" + dependencies: + "@changesets/assemble-release-plan": "npm:^7.0.0" + "@changesets/config": "npm:^4.0.1" + "@changesets/pre": "npm:^3.0.0" + "@changesets/read": "npm:^1.0.1" + "@changesets/types": "npm:^7.0.0" + "@manypkg/get-packages": "npm:^3.1.0" + checksum: 10/26261a7e6889755ed63613b1728dda781480c2344af8c77f66497832ac6c12dc95f11ecf364875ab5fa5f72129b3f4c46102b721d5dce2101e4d293dcbc867f5 + languageName: node + linkType: hard + "@changesets/git@npm:^4.0.1": version: 4.0.1 resolution: "@changesets/git@npm:4.0.1" @@ -1069,7 +1083,11 @@ __metadata: version: 0.0.0-use.local resolution: "@metamask/create-release-branch@workspace:packages/create-release-branch" dependencies: + "@changesets/config": "npm:^4.0.1" + "@changesets/get-release-plan": "npm:^5.0.2" + "@changesets/types": "npm:^7.0.0" "@clack/prompts": "npm:^1.8.1" + "@manypkg/get-packages": "npm:^3.1.0" "@metamask/action-utils": "npm:^2.0.0" "@metamask/auto-changelog": "npm:^7.1.0" "@metamask/utils": "npm:^11.12.0"