@grafana/create-plugin 7.16.0 → 7.18.0

package/src/codemods/additions/scripts/rspack.ts

@@ -0,0 +1,428 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { lt, major, minVersion, validRange } from 'semver';
+import type { Context } from '../../context.js';
+import { replaceExperimentalRspackFlag } from '../../utils.rspack.js';
+import { renderHandlebarsTemplate } from '../../../utils/utils.handlebars.js';
+import { getTemplateData } from '../../../utils/utils.templates.js';
+import {
+  additionsDebug,
+  addDependenciesToPackageJson,
+  readJsonFile,
+  removeDependenciesFromPackageJson,
+  renderTemplate,
+} from '../../utils.js';
+
+const RSPACK_TEMPLATE_DATA_OVERRIDES = {
+  useRspack: true,
+  frontendBundler: 'rspack',
+};
+
+const RSPACK_CONFIG_FILES = [
+  '.config/rspack/rspack.config.ts',
+  '.config/rspack/BuildModeRspackPlugin.ts',
+  '.config/rspack/LiveReloadRspackPlugin.ts',
+  '.config/rspack/LicenseRspackPlugin.ts',
+  '.config/rspack/DiagnosticsRspackPlugin.ts',
+];
+
+// files the rspack template used to ship under another name. removed so they do not linger
+const RETIRED_RSPACK_FILES = ['.config/rspack/liveReloadPlugin.ts'];
+
+// markdown in .config that describes the bundler, for agents and for developers
+const DOC_FILES = ['.config/AGENTS/instructions.md', '.config/README.md'];
+
+const BUNDLER_FILES = [
+  '.config/bundler/constants.ts',
+  '.config/bundler/copyFiles.ts',
+  '.config/bundler/externals.ts',
+  '.config/bundler/utils.ts',
+];
+
+const WEBPACK_CONFIG_PATH = '.config/webpack/webpack.config.ts';
+const RSPACK_CONFIG_PATH = '.config/rspack/rspack.config.ts';
+
+// every file create-plugin has scaffolded into .config/webpack over time. anything else in there
+// was added by the plugin author, so it is kept and reported instead of deleted
+const WEBPACK_TEMPLATE_FILES = [
+  '.config/webpack/BuildModeWebpackPlugin.ts',
+  '.config/webpack/PluginSchemaWebpackPlugin.ts',
+  '.config/webpack/constants.ts',
+  '.config/webpack/generateCode.ts',
+  '.config/webpack/publicPath.ts',
+  '.config/webpack/tsconfig.webpack.json',
+  '.config/webpack/utils.ts',
+  '.config/webpack/watchPluginJson.ts',
+  '.config/webpack/webpack.config.ts',
+  '.config/webpack/webpack.parts.ts',
+];
+
+export default function rspack(context: Context): Context {
+  const hasWebpackSetup = context.doesFileExist(WEBPACK_CONFIG_PATH);
+  const hasRspackSetup = context.doesFileExist(RSPACK_CONFIG_PATH);
+
+  if (!hasWebpackSetup && !hasRspackSetup) {
+    context.setMessage({
+      level: 'warning',
+      title: 'No create-plugin bundler configuration found, so nothing was changed.',
+      body: [`The rspack addition expects ${WEBPACK_CONFIG_PATH} or ${RSPACK_CONFIG_PATH} to exist.`],
+    });
+    return context;
+  }
+
+  const followUps: string[] = [];
+
+  deleteRetiredRspackFiles(context);
+  renderTemplateFiles(context, RSPACK_CONFIG_FILES);
+  renderTemplateFiles(context, BUNDLER_FILES);
+  renderTemplateFiles(context, DOC_FILES, false);
+  replaceExperimentalRspackFlag(context, { enable: true });
+
+  followUps.push(...addRootRspackConfigStub(context));
+  followUps.push(...updatePackageJson(context));
+  followUps.push(...deleteWebpackTemplateFiles(context));
+  reportFollowUps(context, followUps);
+
+  return context;
+}
+
+function deleteRetiredRspackFiles(context: Context): void {
+  for (const filePath of RETIRED_RSPACK_FILES) {
+    if (context.doesFileExist(filePath)) {
+      context.deleteFile(filePath);
+    }
+  }
+}
+
+function reportFollowUps(context: Context, followUps: string[]): void {
+  if (followUps.length === 0) {
+    return;
+  }
+
+  context.setMessage({
+    level: 'warning',
+    title: 'The rspack addition left some things for you to review.',
+    body: followUps,
+  });
+}
+
+const resolveTemplatePath = (relativePath: string) =>
+  fileURLToPath(new URL(`../../../../templates/common/${relativePath}`, import.meta.url));
+
+// updateFile is a no-op for identical content, so re-rendering on every run keeps the addition idempotent
+function renderTemplateFiles(context: Context, filePaths: string[], includeWarning = true): void {
+  const templateData = { ...getTemplateData(), ...RSPACK_TEMPLATE_DATA_OVERRIDES };
+  for (const filePath of filePaths) {
+    const rendered = renderTemplate(resolveTemplatePath(filePath), includeWarning, templateData);
+    if (context.doesFileExist(filePath)) {
+      context.updateFile(filePath, rendered);
+    } else {
+      context.addFile(filePath, rendered);
+    }
+  }
+}
+
+const ROOT_CONFIG_EXTENSIONS = ['ts', 'js', 'cjs', 'mjs', 'cts', 'mts'];
+
+// a root webpack config means the plugin extends the build. the stub makes the build fail loudly
+// until that config is ported, so a plugin cannot ship without the build features it relies on
+function addRootRspackConfigStub(context: Context): string[] {
+  const rootWebpackConfig = ROOT_CONFIG_EXTENSIONS.map((extension) => `webpack.config.${extension}`).find((filePath) =>
+    context.doesFileExist(filePath)
+  );
+  if (!rootWebpackConfig) {
+    return [];
+  }
+
+  const existingRootRspackConfig = ROOT_CONFIG_EXTENSIONS.map((extension) => `rspack.config.${extension}`).find(
+    (filePath) => context.doesFileExist(filePath)
+  );
+  if (existingRootRspackConfig) {
+    return [
+      `${existingRootRspackConfig} already exists, so it was left as is. Check that it includes everything from ${rootWebpackConfig}.`,
+    ];
+  }
+
+  additionsDebug(`Custom ${rootWebpackConfig} detected. Adding a rspack.config.ts stub that fails until it is ported.`);
+  context.addFile('rspack.config.ts', getRootRspackConfigStub(rootWebpackConfig));
+
+  return [
+    `rspack.config.ts was added and fails the build until the customisations in ${rootWebpackConfig} are ported to it.`,
+  ];
+}
+
+interface PackageJson {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
+  engines?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+function updatePackageJson(context: Context): string[] {
+  if (!context.doesFileExist('package.json')) {
+    additionsDebug('No package.json found. Skipping dependency and script updates.');
+    return [];
+  }
+
+  const followUps: string[] = [];
+  const templateVersions = getTemplateDevDependencyVersions();
+  const userBuildFileSources = readUserBuildFileSources(context);
+  const stillUsedDevDependencies = WEBPACK_ONLY_DEV_DEPENDENCIES.filter((name) =>
+    userBuildFileSources.some((source) => referencesPackage(source, name))
+  );
+  const unusedDevDependencies = WEBPACK_ONLY_DEV_DEPENDENCIES.filter(
+    (name) => !stillUsedDevDependencies.includes(name)
+  );
+
+  addDependenciesToPackageJson(
+    context,
+    {},
+    {
+      ...pickVersions(getMissingPackages(context, BASE_CONFIG_DEV_DEPENDENCIES), templateVersions),
+      ...pickVersions(RSPACK_DEV_DEPENDENCIES, templateVersions),
+    }
+  );
+  removeDependenciesFromPackageJson(context, [], unusedDevDependencies);
+
+  if (stillUsedDevDependencies.length > 0) {
+    followUps.push(
+      'These webpack packages were kept because your root build config still uses them. Remove them once the config is ported to rspack:',
+      ...stillUsedDevDependencies.map((name) => `  ${name}`)
+    );
+  }
+
+  const packageJson = readJsonFile<PackageJson>(context, 'package.json');
+  const { scripts, unparsedScripts } = rewriteWebpackScripts(packageJson.scripts ?? {});
+
+  if (packageJson.scripts) {
+    context.updateFile('package.json', JSON.stringify({ ...packageJson, scripts }, null, 2));
+  }
+
+  raiseNodeEngine(context);
+  dropLockedRspackOnePackages(context);
+
+  if (unparsedScripts.length > 0) {
+    followUps.push(
+      'These scripts still call webpack in a way the addition could not rewrite. Change them to call rspack with ./rspack.config.ts or ./.config/rspack/rspack.config.ts:',
+      ...unparsedScripts.map(([name, command]) => `  ${name}: ${command}`)
+    );
+  }
+
+  return followUps;
+}
+
+// rspack 2 needs Node 22.12. 22.23 also has type stripping on by default, so the rspack CLI can
+// always load TypeScript configs natively. matches the engines range create-plugin scaffolds
+const MIN_NODE_VERSION = '22.23.0';
+
+function raiseNodeEngine(context: Context): void {
+  const packageJson = readJsonFile<PackageJson>(context, 'package.json');
+  const nodeRange = packageJson.engines?.node;
+  if (!nodeRange || !validRange(nodeRange)) {
+    return;
+  }
+
+  const lowestAllowedVersion = minVersion(nodeRange);
+  if (!lowestAllowedVersion || !lt(lowestAllowedVersion, MIN_NODE_VERSION)) {
+    return;
+  }
+
+  const engines = { ...packageJson.engines, node: '>=22.23' };
+  context.updateFile('package.json', JSON.stringify({ ...packageJson, engines }, null, 2));
+}
+
+// npm refuses to move @rspack/cli and @rspack/core from 1 to 2 in one install while the lockfile
+// still pins the old versions (ERESOLVE). dropping the locked @rspack packages lets npm resolve
+// them again from package.json. pnpm and yarn upgrade them without help
+const LOCKED_RSPACK_PACKAGE_PATTERN = /(^|\/)node_modules\/@rspack\//;
+
+function dropLockedRspackOnePackages(context: Context): void {
+  if (!context.doesFileExist('package-lock.json')) {
+    return;
+  }
+
+  const lockfile = readJsonFile<{ packages?: Record<string, { version?: string }> }>(context, 'package-lock.json');
+  const lockedCoreVersion = lockfile.packages?.['node_modules/@rspack/core']?.version;
+  if (!lockfile.packages || !lockedCoreVersion || major(lockedCoreVersion) >= 2) {
+    return;
+  }
+
+  const packages = Object.fromEntries(
+    Object.entries(lockfile.packages).filter(([path]) => !LOCKED_RSPACK_PACKAGE_PATTERN.test(path))
+  );
+  context.updateFile('package-lock.json', JSON.stringify({ ...lockfile, packages }, null, 2) + '\n');
+}
+
+// a webpack or webpack-cli command at the start of a script, after a shell separator, after env
+// assignments or after npx. the lookbehind keeps the separator and prefixes out of the match
+const WEBPACK_COMMAND_PATTERN = /(?<=(?:^|&&|\|\||;|\|)\s*(?:\w+=\S*\s+)*(?:npx\s+)?)webpack(?:-cli)?(?=\s|$)/g;
+const ROOT_WEBPACK_CONFIG_ARG_PATTERN =
+  /((?:^|\s)(?:-c|--config)(?:\s+|=))(?:\.\/)?webpack\.config\.[cm]?[jt]s(?=\s|$)/g;
+const TEMPLATE_WEBPACK_CONFIG_ARG_PATTERN =
+  /((?:^|\s)(?:-c|--config)(?:\s+|=))(?:\.\/)?\.config\/webpack\/webpack\.config\.ts(?=\s|$)/g;
+// anything that still runs webpack after the rewrite, e.g. node_modules/webpack-cli/bin/cli.js
+const REMAINING_WEBPACK_PATTERN = /(?:^|[\s/])webpack(?:-cli)?(?:[\s/]|$)|\.config\/webpack\//;
+
+function rewriteWebpackScripts(scripts: Record<string, string>) {
+  const unparsedScripts: Array<[string, string]> = [];
+  const rewrittenScripts = Object.fromEntries(
+    Object.entries(scripts).map(([name, command]) => {
+      const rewritten = command
+        .replace(WEBPACK_COMMAND_PATTERN, 'rspack')
+        .replace(ROOT_WEBPACK_CONFIG_ARG_PATTERN, '$1./rspack.config.ts')
+        .replace(TEMPLATE_WEBPACK_CONFIG_ARG_PATTERN, '$1./.config/rspack/rspack.config.ts');
+
+      if (REMAINING_WEBPACK_PATTERN.test(rewritten)) {
+        unparsedScripts.push([name, command]);
+        return [name, command];
+      }
+
+      return [name, rewritten];
+    })
+  );
+
+  return { scripts: rewrittenScripts, unparsedScripts };
+}
+
+// root level webpack.* and rspack.* files, e.g. webpack.config.ts and helpers like webpack.config.utils.ts
+const USER_BUILD_FILE_PATTERN = /^(webpack|rspack)\.[\w.-]*\.[cm]?[jt]s$/;
+
+function readUserBuildFileSources(context: Context): string[] {
+  return context
+    .readDir('.')
+    .filter((filePath) => USER_BUILD_FILE_PATTERN.test(filePath))
+    .map((filePath) => context.getFile(filePath) ?? '');
+}
+
+// matches the package as a module specifier or loader string: 'name', "name", `name` or 'name/subpath'
+function referencesPackage(source: string, packageName: string): boolean {
+  const escapedName = packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`['"\`]${escapedName}(/[^'"\`]*)?['"\`]`).test(source);
+}
+
+// packages the rspack base config and its helpers need that webpack plugins do not
+export const RSPACK_DEV_DEPENDENCIES = [
+  '@rspack/cli',
+  '@rspack/core',
+  '@types/ws',
+  'diagnostics-webpack-plugin',
+  'rspack-merge',
+  'rspack-plugin-virtual-module',
+  'ts-checker-rspack-plugin',
+  // style-loader and imports-loader still need webpack, and diagnostics-webpack-plugin peers on webpack ^5.106
+  'webpack',
+  'ws',
+];
+
+// packages only the webpack base config uses. removed unless a root build file still imports them
+export const WEBPACK_ONLY_DEV_DEPENDENCIES = [
+  'copy-webpack-plugin',
+  'eslint-webpack-plugin',
+  'fork-ts-checker-webpack-plugin',
+  'swc-loader',
+  'terser-webpack-plugin',
+  'webpack-cli',
+  'webpack-livereload-plugin',
+  'webpack-subresource-integrity',
+  'webpack-virtual-modules',
+];
+
+// packages the rendered .config/rspack and .config/bundler files load at build time that every
+// scaffold gets, so older plugins may have removed some of them. added only when missing.
+// @swc/helpers is needed because builtin:swc-loader runs with externalHelpers, which webpack did not
+export const BASE_CONFIG_DEV_DEPENDENCIES = [
+  '@swc/helpers',
+  'css-loader',
+  'imports-loader',
+  'replace-in-file-webpack-plugin',
+  'sass',
+  'sass-loader',
+  'style-loader',
+];
+
+// the lists above say which packages the addition manages. their versions come from the package.json
+// template, so they always match the .config files rendered from that same template. the template is
+// rendered with fixed data, since only devDependencies are read and they do not depend on the plugin
+const PACKAGE_JSON_TEMPLATE_DATA = {
+  ...RSPACK_TEMPLATE_DATA_OVERRIDES,
+  pluginName: 'plugin',
+  orgName: 'org',
+  pluginType: 'panel',
+  packageManagerName: 'npm',
+  packageManagerVersion: '10.0.0',
+  scenesVersion: '*',
+  isAppType: false,
+  isNPM: true,
+};
+
+export function getTemplateDevDependencyVersions(): Record<string, string> {
+  const template = readFileSync(resolveTemplatePath('_package.json'), 'utf-8');
+  const rendered: { devDependencies?: Record<string, string> } = JSON.parse(
+    renderHandlebarsTemplate(template, PACKAGE_JSON_TEMPLATE_DATA)
+  );
+  return rendered.devDependencies ?? {};
+}
+
+function pickVersions(names: string[], templateVersions: Record<string, string>): Record<string, string> {
+  return Object.fromEntries(
+    names.map((name) => {
+      const version = templateVersions[name];
+      if (!version) {
+        throw new Error(`The package.json template has no version for ${name}, which the rspack addition installs.`);
+      }
+      return [name, version];
+    })
+  );
+}
+
+// a plugin that already has one of these keeps its version
+function getMissingPackages(context: Context, names: string[]): string[] {
+  const packageJson = readJsonFile<PackageJson>(context, 'package.json');
+  const installed = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  return names.filter((name) => !(name in installed));
+}
+
+function deleteWebpackTemplateFiles(context: Context): string[] {
+  for (const filePath of WEBPACK_TEMPLATE_FILES) {
+    if (context.doesFileExist(filePath)) {
+      context.deleteFile(filePath);
+    }
+  }
+
+  const leftoverFiles = context.readDir('.config/webpack');
+  if (leftoverFiles.length === 0) {
+    return [];
+  }
+
+  return [
+    'These files in .config/webpack were not created by create-plugin, so they were kept. Move anything you still need out of .config and port it to rspack:',
+    ...leftoverFiles.map((filePath) => `  ${filePath}`),
+  ];
+}
+
+function getRootRspackConfigStub(rootWebpackConfig: string): string {
+  return `import type { Configuration } from '@rspack/core';
+import { merge } from 'rspack-merge';
+
+import grafanaConfig, { type Env } from './.config/rspack/rspack.config.ts';
+
+// TODO(rspack): port the customisations in ./${rootWebpackConfig} to this file, then delete it.
+// Run \`npx @grafana/create-plugin@latest add rspack --agent\` to have an AI agent do the port,
+// or follow https://grafana.com/developers/plugin-tools/how-to-guides/extend-configurations
+// This file is loaded as native ESM, so CommonJS globals are not available. Use import.meta.dirname,
+// createRequire(import.meta.url) and .ts extensions on relative imports.
+throw new Error(
+  '[rspack] ${rootWebpackConfig} has not been ported to rspack.config.ts yet. ' +
+    'Run \`npx @grafana/create-plugin@latest add rspack --agent\` or port it by hand, then remove this error.'
+);
+
+const config = async (env: Env): Promise<Configuration> => {
+  const baseConfig = await grafanaConfig(env);
+
+  return merge(baseConfig, {});
+};
+
+export default config;
+`;
+}

package/src/codemods/agentic/prompts.test.ts

@@ -89,8 +89,17 @@ describe('buildSystemPrompt', () => {
     expect(systemPrompt).toContain('Write it with your file-writing tool, not a shell command.');
   });
 
-  it('should tell the agent to fix failing checks rather than suppress them', () => {
-    expect(systemPrompt).toContain('fix the cause. Never make it pass by suppressing it');
+  it('should tell the agent to fix failing checks rather than hide them', () => {
+    expect(systemPrompt).toContain('fix the cause. Never hide a failure');
+  });
+
+  it('should defer to the addition instructions for setting aside what cannot be applied', () => {
+    // additions keep the build passing by commenting out unportable code under a TODO marker,
+    // so the contract must not forbid that or tell the agent to leave the check failing instead
+    expect(systemPrompt).toContain(
+      'If the addition instructions say how to set aside something that cannot be applied, such as commenting it out under a `TODO(<addition-name>):` marker, follow them.'
+    );
+    expect(systemPrompt).not.toMatch(/or changed scripts\./);
   });
 
   it('should render the package manager commands', () => {

package/src/codemods/agentic/prompts.ts

@@ -76,7 +76,7 @@ Before changing any file, print a short plan of what you intend to do so the use
 
 <scope_rules>
 Make only the changes the addition instructions require. Do not run package installs, builds, or tests unless the instructions ask for them. Run the repository formatter on files you touched if one is configured. Do not reformat files you did not change.
-When a check fails (typecheck, lint, build or tests), fix the cause. Never make it pass by suppressing it: no disable comments, skipped or deleted tests, loosened compiler or lint settings, or changed scripts. If you cannot fix the cause, leave it failing and say so in your summary.
+When a check fails (typecheck, lint, build or tests), fix the cause. Never hide a failure: no disable comments, skipped or deleted tests, loosened compiler or lint settings, or scripts changed to skip the check. If the addition instructions say how to set aside something that cannot be applied, such as commenting it out under a \`TODO(<addition-name>):\` marker, follow them. Otherwise leave the check failing and say so in your summary.
 </scope_rules>
 
 <handoff_contract>

package/src/codemods/migrations/migrations.ts

@@ -127,9 +127,22 @@ export default [
       'Replace eslint-webpack-plugin with diagnostics-webpack-plugin in the webpack config. eslint-webpack-plugin depends on micromatch, which pulls in the braces dependency flagged by vulnerability scanners.',
     scriptPath: import.meta.resolve('./scripts/018-replace-eslint-webpack-plugin.js'),
   },
+  {
+    name: '019-remove-glob-dependency',
+    version: '7.17.0',
+    description: 'Replace the glob package with the Node.js built-in fs.glob in bundler utils.',
+    scriptPath: import.meta.resolve('./scripts/019-remove-glob-dependency.js'),
+  },
+  {
+    name: '020-rename-rspack-feature-flag',
+    version: '7.18.0',
+    description:
+      'Rename the useExperimentalRspack feature flag to useRspack in .config/.cprc.json, and remove it from the plugin .cprc.json.',
+    scriptPath: import.meta.resolve('./scripts/020-rename-rspack-feature-flag.js'),
+  },
   // Do not use LEGACY_UPDATE_CUTOFF_VERSION for new migrations. It is only used above to force migrations to run
   // for those written before the switch to updates as migrations.
   //
-  // New migrations never pick a version: copy the unreleased version line from ../AGENTS.md exactly.
+  // New migrations should never specify a version: copy the unreleased version line from ../AGENTS.md exactly.
   // Do not paste it into a comment in this file, as release-please rewrites every line that carries it.
 ] satisfies Migration[];

package/src/codemods/migrations/scripts/019-remove-glob-dependency.test.ts

@@ -0,0 +1,146 @@
+import { readFileSync } from 'node:fs';
+import { describe, expect, it } from 'vitest';
+import migrate from './019-remove-glob-dependency.js';
+import { createDefaultContext } from '../../test-utils.js';
+
+const BUNDLER_UTILS_PATH = '.config/bundler/utils.ts';
+const WEBPACK_UTILS_PATH = '.config/webpack/utils.ts';
+
+const CURRENT_UTILS = readFileSync(
+  new URL('../../../../templates/common/.config/bundler/utils.ts', import.meta.url),
+  'utf-8'
+);
+
+const NEW_GLOB_IMPORT = "import { glob } from 'node:fs/promises';";
+const CONSTANTS_IMPORT = "import { SOURCE_DIR } from './constants.ts';";
+
+// The migration appends the new import after the existing ones, so it lands below the constants import.
+const MIGRATED_UTILS = CURRENT_UTILS.replace(`${NEW_GLOB_IMPORT}\n`, '').replace(
+  CONSTANTS_IMPORT,
+  `${CONSTANTS_IMPORT}\n${NEW_GLOB_IMPORT}`
+);
+
+// The template's utils.ts as scaffolded before the glob package was removed.
+const SCAFFOLDED_UTILS = CURRENT_UTILS.replace(
+  "import { glob } from 'node:fs/promises';",
+  "import { glob } from 'glob';"
+).replace(
+  /export async function getEntries\(\) \{[\s\S]*?\n {2}return plugins\.reduce/,
+  `export async function getEntries() {
+  const pluginsJson = await glob('**/src/**/plugin.json', { absolute: true });
+
+  const plugins = await Promise.all(
+    pluginsJson.map((pluginJson) => {
+      const folder = path.dirname(pluginJson);
+      return glob(\`\${folder}/module.{ts,tsx,js,jsx}\`, { absolute: true });
+    })
+  );
+
+  return plugins.reduce`
+);
+
+function createContextWithGlob(utilsPath = BUNDLER_UTILS_PATH, utilsContent = SCAFFOLDED_UTILS) {
+  const context = createDefaultContext();
+  context.addFile(utilsPath, utilsContent);
+  context.updateFile(
+    'package.json',
+    JSON.stringify({ devDependencies: { '@grafana/tsconfig': '^2.0.1', glob: '^11.1.0' } }, null, 2)
+  );
+
+  return context;
+}
+
+function getDevDependencies(context: ReturnType<typeof createDefaultContext>) {
+  return JSON.parse(context.getFile('package.json') ?? '{}').devDependencies;
+}
+
+describe('Migration - remove glob dependency', () => {
+  it('should be idempotent', async () => {
+    const context = createContextWithGlob();
+
+    await expect(migrate).toBeIdempotent(context);
+  });
+
+  it('should migrate the scaffolded utils to the current template', () => {
+    const context = migrate(createContextWithGlob());
+
+    expect(context.getFile(BUNDLER_UTILS_PATH)).toBe(MIGRATED_UTILS);
+  });
+
+  it('should migrate the legacy webpack utils location', () => {
+    const context = migrate(createContextWithGlob(WEBPACK_UTILS_PATH));
+
+    expect(context.getFile(WEBPACK_UTILS_PATH)).toBe(MIGRATED_UTILS);
+  });
+
+  it('should remove glob from package.json', () => {
+    const context = migrate(createContextWithGlob());
+
+    expect(getDevDependencies(context)).toEqual({ '@grafana/tsconfig': '^2.0.1' });
+  });
+
+  it('should migrate a customised getEntries that calls glob', () => {
+    const customisedUtils = SCAFFOLDED_UTILS.replace(
+      '{ absolute: true });\n\n  const plugins',
+      "{ absolute: true, ignore: ['node_modules/**'] });\n\n  const plugins"
+    );
+    const context = migrate(createContextWithGlob(BUNDLER_UTILS_PATH, customisedUtils));
+
+    expect(context.getFile(BUNDLER_UTILS_PATH)).toBe(MIGRATED_UTILS);
+  });
+
+  it('should skip a getEntries that does not call glob', () => {
+    const noGlobCallUtils = SCAFFOLDED_UTILS.replace(
+      "const pluginsJson = await glob('**/src/**/plugin.json', { absolute: true });",
+      "const pluginsJson = ['src/plugin.json'];"
+    ).replace('return glob(', 'return Promise.resolve(');
+    const context = createContextWithGlob(BUNDLER_UTILS_PATH, noGlobCallUtils);
+
+    migrate(context);
+
+    expect(context.getFile(BUNDLER_UTILS_PATH)).toBe(noGlobCallUtils);
+    expect(getDevDependencies(context).glob).toBe('^11.1.0');
+  });
+
+  it('should skip an aliased glob import', () => {
+    const aliasedUtils = SCAFFOLDED_UTILS.replace("import { glob } from 'glob';", "import { glob as g } from 'glob';")
+      .replaceAll('await glob(', 'await g(')
+      .replace('return glob(', 'return g(');
+    const context = createContextWithGlob(BUNDLER_UTILS_PATH, aliasedUtils);
+
+    migrate(context);
+
+    expect(context.getFile(BUNDLER_UTILS_PATH)).toBe(aliasedUtils);
+    expect(getDevDependencies(context).glob).toBe('^11.1.0');
+  });
+
+  it('should keep other glob specifiers and the dependency', () => {
+    const mixedUtils = SCAFFOLDED_UTILS.replace(
+      "import { glob } from 'glob';",
+      "import { glob, globSync } from 'glob';"
+    );
+    const context = migrate(createContextWithGlob(BUNDLER_UTILS_PATH, mixedUtils));
+    const migrated = context.getFile(BUNDLER_UTILS_PATH);
+
+    expect(migrated).toContain("import { globSync } from 'glob';");
+    expect(migrated).toContain("import { glob } from 'node:fs/promises';");
+    expect(migrated).toContain("for await (const pluginJson of glob('**/src/**/plugin.json'))");
+    expect(getDevDependencies(context).glob).toBe('^11.1.0');
+  });
+
+  it('should leave files without a glob import unchanged', () => {
+    const context = createContextWithGlob(BUNDLER_UTILS_PATH, CURRENT_UTILS);
+
+    migrate(context);
+
+    expect(context.getFile(BUNDLER_UTILS_PATH)).toBe(CURRENT_UTILS);
+    expect(getDevDependencies(context).glob).toBe('^11.1.0');
+  });
+
+  it('should not fail when the utils file cannot be parsed', () => {
+    const context = createContextWithGlob(BUNDLER_UTILS_PATH, "import { glob } from 'glob';\nexport function {");
+
+    expect(() => migrate(context)).not.toThrow();
+    expect(getDevDependencies(context).glob).toBe('^11.1.0');
+  });
+});