@next/codemod 16.3.0-preview.5 → 16.3.0-preview.7

package/bin/next-codemod.js

@@ -43,6 +43,7 @@ program
     .argument('[revision]', 'Specify the upgrade type ("patch", "minor", "major"), an NPM dist tag (e.g. "latest", "canary", "rc"), or an exact version (e.g. "15.0.0"). Defaults to "minor".')
     .usage('[revision] [options]')
     .option('--verbose', 'Verbose output', false)
+    .option('-y, --yes', 'Skip every interactive prompt and accept its default. Also auto-enabled when stdin is not a TTY (e.g. running under an agent or in CI).', false)
     .action(async (revision, options) => {
     try {
         await (0, upgrade_1.runUpgrade)(revision, options);

package/bin/upgrade.js

@@ -47,6 +47,7 @@ const picocolors_1 = __importDefault(require("picocolors"));
 const handle_package_1 = require("../lib/handle-package");
 const transform_1 = require("./transform");
 const utils_1 = require("../lib/utils");
+const agents_md_1 = require("../lib/agents-md");
 const shared_1 = require("./shared");
 const optionalNextjsPackages = [
     'create-next-app',
@@ -114,6 +115,10 @@ function resolveSemanticRevision(revision, installedVersion) {
 }
 async function runUpgrade(revision, options) {
     const { verbose } = options;
+    const nonInteractive = options.yes === true || !process.stdin.isTTY;
+    if (nonInteractive) {
+        console.log(`  Running in non-interactive mode. Every prompt will accept its default.`);
+    }
     const appPackageJsonPath = path_1.default.resolve(cwd, 'package.json');
     let appPackageJson = JSON.parse(fs_1.default.readFileSync(appPackageJsonPath, 'utf8'));
     const installedNextVersion = getInstalledNextVersion();
@@ -189,18 +194,24 @@ async function runUpgrade(revision, options) {
         // The mixed case is tricky to handle from a types perspective.
         // We'll recommend to upgrade in the prompt but users can decide to try 18.
         !isPureAppRouter) {
-        const shouldStayOnReact18Res = await (0, prompts_1.default)({
-            type: 'confirm',
-            name: 'shouldStayOnReact18',
-            message: `Do you prefer to stay on React 18?` +
-                (isMixedApp
-                    ? " Since you're using both pages/ and app/, we recommend upgrading React to use a consistent version throughout your app."
-                    : ''),
-            initial: false,
-            active: 'Yes',
-            inactive: 'No',
-        }, { onCancel: utils_1.onCancel });
-        shouldStayOnReact18 = shouldStayOnReact18Res.shouldStayOnReact18;
+        if (nonInteractive) {
+            // Default: upgrade React past 18.
+            shouldStayOnReact18 = false;
+        }
+        else {
+            const shouldStayOnReact18Res = await (0, prompts_1.default)({
+                type: 'confirm',
+                name: 'shouldStayOnReact18',
+                message: `Do you prefer to stay on React 18?` +
+                    (isMixedApp
+                        ? " Since you're using both pages/ and app/, we recommend upgrading React to use a consistent version throughout your app."
+                        : ''),
+                initial: false,
+                active: 'Yes',
+                inactive: 'No',
+            }, { onCancel: utils_1.onCancel });
+            shouldStayOnReact18 = shouldStayOnReact18Res.shouldStayOnReact18;
+        }
     }
     // We're resolving a specific version here to avoid including "ugly" version queries
     // in the manifest.
@@ -212,9 +223,9 @@ async function runUpgrade(revision, options) {
         : await loadHighestNPMVersionMatching(`react@${targetNextPackageJson.peerDependencies['react']}`);
     if ((0, semver_1.compare)(targetNextVersion, '15.0.0-canary') >= 0 &&
         (0, semver_1.compare)(targetNextVersion, '16.0.0-canary') < 0) {
-        await suggestTurbopack(appPackageJson, targetNextVersion);
+        await suggestTurbopack(appPackageJson, targetNextVersion, nonInteractive);
     }
-    const codemods = await suggestCodemods(installedNextVersion, targetNextVersion);
+    const codemods = await suggestCodemods(installedNextVersion, targetNextVersion, nonInteractive);
     const packageManager = (0, handle_package_1.getPkgManager)(cwd);
     let shouldRunReactCodemods = false;
     let shouldRunReactTypesCodemods = false;
@@ -223,8 +234,9 @@ async function runUpgrade(revision, options) {
     if (!shouldStayOnReact18 &&
         (0, semver_1.compare)(targetReactVersion, '19.0.0-0') >= 0 &&
         (0, semver_1.compare)(installedReactVersion, '19.0.0-0') < 0) {
-        shouldRunReactCodemods = await suggestReactCodemods();
-        shouldRunReactTypesCodemods = await suggestReactTypesCodemods();
+        shouldRunReactCodemods = await suggestReactCodemods(nonInteractive);
+        shouldRunReactTypesCodemods =
+            await suggestReactTypesCodemods(nonInteractive);
         execCommand = getNpxCommand(packageManager);
     }
     fs_1.default.writeFileSync(appPackageJsonPath, JSON.stringify(appPackageJson, null, 2));
@@ -284,6 +296,37 @@ async function runUpgrade(revision, options) {
             };
         }
     }
+    // Bump `eslint` alongside `eslint-config-next` so the install doesn't fail
+    // on a peer-dep mismatch. e.g. `eslint-config-next@16.x` requires
+    // `eslint@>=9`, but a project upgrading from Next 15 will still have
+    // `eslint@^8` from create-next-app. Skip silently if anything goes wrong;
+    // the worst case is the user hits the same peer-dep error they would have
+    // without this bump.
+    //
+    // Only act when the project is actually using `eslint-config-next` — we
+    // don't want to silently upgrade eslint majors for projects that use
+    // eslint for unrelated reasons.
+    if (allDependencies['eslint'] && allDependencies['eslint-config-next']) {
+        try {
+            const eslintConfigNextPeerDepsJSON = (0, child_process_1.execSync)(`npm --silent view "eslint-config-next@${targetNextVersion}" peerDependencies --json`, { encoding: 'utf-8' });
+            const eslintConfigNextPeerDeps = eslintConfigNextPeerDepsJSON.trim() === ''
+                ? {}
+                : JSON.parse(eslintConfigNextPeerDepsJSON);
+            const eslintRange = eslintConfigNextPeerDeps?.eslint;
+            if (eslintRange) {
+                const targetEslintVersion = await loadHighestNPMVersionMatching(`eslint@${eslintRange}`);
+                versionMapping['eslint'] = {
+                    version: targetEslintVersion,
+                    required: false,
+                };
+            }
+        }
+        catch (e) {
+            if (verbose) {
+                console.warn(`  Could not determine eslint peer range from eslint-config-next@${targetNextVersion}. Leaving eslint version alone.`, e);
+            }
+        }
+    }
     // Even though we only need those if we alias `@types/react` to types-react,
     // we still do it out of safety due to https://github.com/microsoft/DefinitelyTyped-tools/issues/433.
     const overrides = {};
@@ -320,10 +363,11 @@ async function runUpgrade(revision, options) {
     // understanding of the codemods, we run all of the applicable codemods.
     if (shouldRunReactCodemods) {
         // https://react.dev/blog/2024/04/25/react-19-upgrade-guide#run-all-react-19-codemods
-        (0, child_process_1.execSync)(
         // `--no-interactive` skips the interactive prompt that asks for confirmation
         // https://github.com/codemod-com/codemod/blob/c0cf00d13161a0ec0965b6cc6bc5d54076839cc8/apps/cli/src/flags.ts#L160
-        `${execCommand} codemod@latest react/19/migration-recipe --no-interactive`, { stdio: 'inherit' });
+        // `--allow-dirty` is required because the upgrade above modified package.json
+        // and the lockfile; the recipe refuses to run on a dirty tree otherwise.
+        (0, child_process_1.execSync)(`${execCommand} codemod@latest react/19/migration-recipe --no-interactive --allow-dirty`, { stdio: 'inherit' });
     }
     if (shouldRunReactTypesCodemods) {
         // https://react.dev/blog/2024/04/25/react-19-upgrade-guide#typescript-changes
@@ -337,6 +381,14 @@ async function runUpgrade(revision, options) {
     if (codemods.length > 0) {
         console.log(`${picocolors_1.default.green('✔')} Codemods have been applied successfully.`);
     }
+    try {
+        if ((0, agents_md_1.refreshAgentRulesBlock)(cwd) === 'refreshed') {
+            console.log(`${picocolors_1.default.green('✔')} Refreshed the managed agent-rules block in AGENTS.md / CLAUDE.md to match the upgraded Next.js.`);
+        }
+    }
+    catch {
+        // The block refresh is best-effort — never fail the upgrade over it.
+    }
     warnDependenciesOutOfRange(appPackageJson, versionMapping);
     endMessage(targetNextVersion);
 }
@@ -383,7 +435,7 @@ function isUsingAppDir(projectPath) {
  * 3. Otherwise, we ask the user to manually add `--turbopack` to their dev command,
  *    showing the current dev command as the initial value.
  */
-async function suggestTurbopack(packageJson, targetNextVersion) {
+async function suggestTurbopack(packageJson, targetNextVersion, nonInteractive) {
     const devScript = packageJson.scripts?.['dev'];
     // Turbopack flag was changed from `--turbo` to `--turbopack` in v15.0.1-canary.3
     // PR: https://github.com/vercel/next.js/pull/71657
@@ -406,19 +458,28 @@ async function suggestTurbopack(packageJson, targetNextVersion) {
             }
             return;
         }
-        const responseTurbopack = await (0, prompts_1.default)({
-            type: 'confirm',
-            name: 'enable',
-            message: `Enable Turbopack for ${picocolors_1.default.bold('next dev')}?`,
-            initial: true,
-        }, { onCancel: utils_1.onCancel });
-        if (!responseTurbopack.enable) {
+        let enable = true;
+        if (!nonInteractive) {
+            const responseTurbopack = await (0, prompts_1.default)({
+                type: 'confirm',
+                name: 'enable',
+                message: `Enable Turbopack for ${picocolors_1.default.bold('next dev')}?`,
+                initial: true,
+            }, { onCancel: utils_1.onCancel });
+            enable = responseTurbopack.enable;
+        }
+        if (!enable) {
             return;
         }
         packageJson.scripts['dev'] = devScript.replace('next dev', `next dev ${turboPackFlag}`);
         return;
     }
     console.log(`${picocolors_1.default.yellow('⚠')} Could not find "${picocolors_1.default.bold('next dev')}" in your dev script.`);
+    if (nonInteractive) {
+        // Without a TTY we can't ask the user for a replacement script.
+        // Keep the existing dev script untouched.
+        return;
+    }
     const responseCustomDevScript = await (0, prompts_1.default)({
         type: 'text',
         name: 'customDevScript',
@@ -428,7 +489,7 @@ async function suggestTurbopack(packageJson, targetNextVersion) {
     packageJson.scripts['dev'] =
         responseCustomDevScript.customDevScript || devScript;
 }
-async function suggestCodemods(initialNextVersion, targetNextVersion) {
+async function suggestCodemods(initialNextVersion, targetNextVersion, nonInteractive) {
     // example:
     // codemod version: 15.0.0-canary.45
     // 14.3             -> 15.0.0-canary.45: apply
@@ -451,6 +512,13 @@ async function suggestCodemods(initialNextVersion, targetNextVersion) {
     if (relevantCodemods.length === 0) {
         return [];
     }
+    if (nonInteractive) {
+        // Default: apply every recommended codemod, matching `selected: true` below.
+        const all = relevantCodemods.map(({ value }) => value);
+        console.log(`  Applying all ${picocolors_1.default.blue('codemods')} recommended for your upgrade:\n` +
+            all.map((value) => `    - ${value}`).join('\n'));
+        return all;
+    }
     const { codemods } = await (0, prompts_1.default)({
         type: 'multiselect',
         name: 'codemods',
@@ -466,7 +534,10 @@ async function suggestCodemods(initialNextVersion, targetNextVersion) {
     }, { onCancel: utils_1.onCancel });
     return codemods;
 }
-async function suggestReactCodemods() {
+async function suggestReactCodemods(nonInteractive) {
+    if (nonInteractive) {
+        return true;
+    }
     const { runReactCodemod } = await (0, prompts_1.default)({
         type: 'confirm',
         name: 'runReactCodemod',
@@ -475,7 +546,10 @@ async function suggestReactCodemods() {
     }, { onCancel: utils_1.onCancel });
     return runReactCodemod;
 }
-async function suggestReactTypesCodemods() {
+async function suggestReactTypesCodemods(nonInteractive) {
+    if (nonInteractive) {
+        return true;
+    }
     const { runReactTypesCodemod } = await (0, prompts_1.default)({
         type: 'confirm',
         name: 'runReactTypesCodemod',

package/lib/agents-md.js

@@ -9,6 +9,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshAgentRulesBlock = refreshAgentRulesBlock;
 exports.getNextjsVersion = getNextjsVersion;
 exports.getBundledDocsInfo = getBundledDocsInfo;
 exports.getBundledDocsLinkPath = getBundledDocsLinkPath;
@@ -22,6 +23,49 @@ const execa_1 = __importDefault(require("execa"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
+const AGENT_RULES_START_MARKER = '<!-- BEGIN:nextjs-agent-rules -->';
+/**
+ * After an upgrade, refresh the managed agent-rules block in
+ * AGENTS.md / CLAUDE.md so its content matches the Next.js version
+ * that is now installed.
+ *
+ * Delegates to the installed package's own generator
+ * (`next/dist/server/lib/generate-agent-files`), so the block text is
+ * always the one shipped with that version — this codemod never
+ * carries its own copy. Returns `'refreshed'` when a file was
+ * rewritten, `'current'` when the block was already up to date, and
+ * `'skipped'` when there is nothing to do: the project never adopted
+ * the managed block, or the installed Next.js predates the generator
+ * (< 16.3).
+ */
+function refreshAgentRulesBlock(cwd) {
+    const hostsBlock = ['AGENTS.md', 'CLAUDE.md'].some((file) => {
+        try {
+            return fs_1.default
+                .readFileSync(path_1.default.join(cwd, file), 'utf-8')
+                .includes(AGENT_RULES_START_MARKER);
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!hostsBlock)
+        return 'skipped';
+    let writeAgentFiles;
+    try {
+        const generatorPath = require.resolve('next/dist/server/lib/generate-agent-files', { paths: [cwd] });
+        writeAgentFiles = require(generatorPath).writeAgentFiles;
+        if (typeof writeAgentFiles !== 'function')
+            return 'skipped';
+    }
+    catch {
+        return 'skipped';
+    }
+    const result = writeAgentFiles(cwd);
+    return result.agentsMd === 'updated' || result.claudeMd === 'updated'
+        ? 'refreshed'
+        : 'current';
+}
 function getNextjsVersion(cwd) {
     try {
         const nextPkgPath = require.resolve('next/package.json', { paths: [cwd] });

package/lib/utils.js

@@ -137,5 +137,10 @@ exports.TRANSFORMER_INQUIRER_CHOICES = [
         value: 'cache-components-instant-false',
         version: '16.3.0',
     },
+    {
+        title: "Remove `export const prefetch = 'partial'` Route Segment Config from App Router pages and layouts after enabling `partialPrefetching` globally",
+        value: 'remove-partial-prefetch',
+        version: '16.3.0',
+    },
 ];
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/codemod",
-  "version": "16.3.0-preview.5",
+  "version": "16.3.0-preview.7",
   "license": "MIT",
   "repository": {
     "type": "git",

package/transforms/next-experimental-turbo-to-turbopack.js

@@ -18,7 +18,7 @@ const utils_1 = require("./lib/utils");
 // Properties that need to be moved to experimental.turbopack*
 const RENAMED_EXPERIMENTAL_PROPERTIES = {
     minify: 'turbopackMinify',
-    treeShaking: 'turbopackTreeShaking',
+    treeShaking: 'turbopackModuleFragments',
     sourceMaps: 'turbopackSourceMaps',
 };
 // `memoryLimit` is no longer supported and is removed entirely. We drop it under

package/transforms/remove-partial-prefetch.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const parser_1 = require("../lib/parser");
+// Route Segment Config name and the only value this codemod strips.
+const CONFIG_NAME = 'prefetch';
+const TARGET_VALUE = 'partial';
+// Unwrap `'partial' as const` / `'partial' satisfies T` so the value guard
+// still matches when the export is annotated.
+function unwrap(j, node) {
+    if ((j.TSAsExpression && j.TSAsExpression.check(node)) ||
+        (j.TSSatisfiesExpression && j.TSSatisfiesExpression.check(node))) {
+        return node.expression;
+    }
+    return node;
+}
+// Only `prefetch = 'partial'` matches. A different value such as
+// `prefetch = 'allow-runtime'` is a legitimate config and is left untouched.
+function isTargetPrefetch(j, decl) {
+    if (!j.VariableDeclarator.check(decl) || !j.Identifier.check(decl.id)) {
+        return false;
+    }
+    if (decl.id.name !== CONFIG_NAME || !decl.init) {
+        return false;
+    }
+    const init = unwrap(j, decl.init);
+    return ((j.StringLiteral.check(init) && init.value === TARGET_VALUE) ||
+        (j.Literal.check(init) && init.value === TARGET_VALUE));
+}
+// Drop only the `prefetch = 'partial'` declarator, leaving any sibling
+// declarators (e.g. `export const runtime = 'edge', prefetch = 'partial'`)
+// intact. Returns the number of declarators left so the caller can remove the
+// whole statement when it becomes empty.
+function stripTargetDeclarators(j, declaration) {
+    declaration.declarations = declaration.declarations.filter((decl) => !isTargetPrefetch(j, decl));
+    return declaration.declarations.length;
+}
+// Removing a statement also removes the comments attached above it — which
+// may be a user's note or a deliberate `// TODO(...)` marker. Reattach the
+// leading comments to the next statement (or the previous one when the
+// removed statement is last) so they survive the removal.
+function preserveLeadingComments(path) {
+    const comments = path.node.comments?.filter((comment) => comment.leading);
+    if (!comments?.length) {
+        return;
+    }
+    const body = path.parent.node.body;
+    if (!Array.isArray(body)) {
+        return;
+    }
+    const index = body.indexOf(path.node);
+    const next = body[index + 1];
+    const prev = body[index - 1];
+    if (next) {
+        next.comments = [...comments, ...(next.comments ?? [])];
+    }
+    else if (prev) {
+        for (const comment of comments) {
+            comment.leading = false;
+            comment.trailing = true;
+        }
+        prev.comments = [...(prev.comments ?? []), ...comments];
+    }
+}
+function transformer(file, _api) {
+    // Run on App Router page/layout files, except for test environment. The
+    // `prefetch` Route Segment Config only applies to pages and layouts, so
+    // route handlers are intentionally excluded.
+    // `(^|[/\\])app` matches both an absolute path and a relative `app/...` path
+    // (what `npx @next/codemod ... ./app` passes), so top-level app files aren't
+    // silently skipped.
+    if (process.env.NODE_ENV !== 'test' &&
+        !/(^|[/\\])app[/\\](?:.*[/\\])?(page|layout)(\.[^/\\]*)?$/.test(file.path)) {
+        return file.source;
+    }
+    const j = (0, parser_1.createParserFromPath)(file.path);
+    const root = j(file.source);
+    let hasChanges = false;
+    // `export const prefetch = 'partial'` (possibly alongside other configs in
+    // the same statement).
+    root
+        .find(j.ExportNamedDeclaration, {
+        declaration: { type: 'VariableDeclaration' },
+    })
+        .filter((path) => {
+        const declaration = path.node.declaration;
+        return (j.VariableDeclaration.check(declaration) &&
+            declaration.declarations.some((decl) => isTargetPrefetch(j, decl)));
+    })
+        .forEach((path) => {
+        const declaration = path.node.declaration;
+        const remaining = stripTargetDeclarators(j, declaration);
+        // Remove the whole export only when nothing else was declared with it.
+        if (remaining === 0) {
+            preserveLeadingComments(path);
+            j(path).remove();
+        }
+        hasChanges = true;
+    });
+    // Bare `const prefetch = 'partial'` declarations are only Route Segment
+    // Configs when the file also exports them as `prefetch` via a local
+    // `export { prefetch }`. Re-exports (`export { prefetch } from '...'`) bind
+    // another module's value, and aliased exports export a different name
+    // (`export { prefetch as other }`) or a different binding
+    // (`export { other as prefetch }`), so neither counts. When an aliased
+    // export shares the `prefetch` binding, removing the declaration would
+    // break it, so the whole file is left untouched.
+    let hasPlainPrefetchExportSpecifier = false;
+    let hasAliasedPrefetchBinding = false;
+    root
+        .find(j.ExportNamedDeclaration)
+        .filter((path) => !path.node.source)
+        .forEach((path) => {
+        for (const spec of path.node.specifiers ?? []) {
+            if (!j.ExportSpecifier.check(spec) ||
+                !j.Identifier.check(spec.local) ||
+                spec.local.name !== CONFIG_NAME) {
+                continue;
+            }
+            if (j.Identifier.check(spec.exported) &&
+                spec.exported.name === CONFIG_NAME) {
+                hasPlainPrefetchExportSpecifier = true;
+            }
+            else {
+                hasAliasedPrefetchBinding = true;
+            }
+        }
+    });
+    const hasLocalPrefetchExportSpecifier = hasPlainPrefetchExportSpecifier && !hasAliasedPrefetchBinding;
+    // Track that we removed a bare declaration so we only drop the matching
+    // export specifier below.
+    let removedBareDeclaration = false;
+    if (hasLocalPrefetchExportSpecifier) {
+        root
+            .find(j.VariableDeclaration)
+            .filter((path) => {
+            // `export const prefetch` is handled above; skip it here.
+            if (j.ExportNamedDeclaration.check(path.parent.node)) {
+                return false;
+            }
+            // Only top-level declarations can be the exported config. A local
+            // `const prefetch` inside a function or block is unrelated code.
+            if (!j.Program.check(path.parent.node)) {
+                return false;
+            }
+            return path.node.declarations.some((decl) => isTargetPrefetch(j, decl));
+        })
+            .forEach((path) => {
+            const remaining = stripTargetDeclarators(j, path.node);
+            if (remaining === 0) {
+                preserveLeadingComments(path);
+                j(path).remove();
+            }
+            removedBareDeclaration = true;
+            hasChanges = true;
+        });
+    }
+    // Handle `export { prefetch }` and `export { prefetch, other }`, but only
+    // when the paired declaration was the `'partial'` one we removed above.
+    if (removedBareDeclaration) {
+        root
+            .find(j.ExportNamedDeclaration)
+            // Skip re-exports (`export { prefetch } from '...'`): their specifiers
+            // reference another module's binding, not the declaration we removed.
+            .filter((path) => !path.node.source && Boolean(path.node.specifiers?.length))
+            .forEach((path) => {
+            const specifiers = path.node.specifiers;
+            if (!specifiers)
+                return;
+            const filteredSpecifiers = specifiers.filter((spec) => {
+                // Remove only the plain `export { prefetch }` specifier. Aliased
+                // specifiers export a different name or bind a different value, so
+                // they aren't the Route Segment Config.
+                if (j.ExportSpecifier.check(spec) &&
+                    j.Identifier.check(spec.local) &&
+                    j.Identifier.check(spec.exported)) {
+                    return !(spec.local.name === CONFIG_NAME &&
+                        spec.exported.name === CONFIG_NAME);
+                }
+                return true;
+            });
+            if (filteredSpecifiers.length !== specifiers.length) {
+                hasChanges = true;
+                if (filteredSpecifiers.length === 0) {
+                    preserveLeadingComments(path);
+                    j(path).remove();
+                }
+                else {
+                    path.node.specifiers = filteredSpecifiers;
+                }
+            }
+        });
+    }
+    if (hasChanges) {
+        return root.toSource();
+    }
+    return file.source;
+}
+//# sourceMappingURL=remove-partial-prefetch.js.map