@next/codemod 15.4.7 → 15.5.0

package/README.md

@@ -6,4 +6,4 @@ Codemods are transformations that run on your codebase programmatically. This al
 
 ## Documentation
 
-Visit [nextjs.org/docs/advanced-features/codemods](https://nextjs.org/docs/advanced-features/codemods) to view the documentation for this package.
+Visit [nextjs.org/docs/advanced-features/codemods](https://nextjs.org/docs/app/guides/upgrading/codemods) to view the documentation for this package.

package/bin/transform.js

@@ -78,6 +78,10 @@ async function runTransform(transform, path, options) {
         // cra-to-next transform doesn't use jscodeshift directly
         return require(transformerPath).default(filesExpanded, options);
     }
+    if (transformer === 'next-lint-to-eslint-cli') {
+        // next-lint-to-eslint-cli transform doesn't use jscodeshift directly
+        return require(transformerPath).default(filesExpanded, options);
+    }
     let args = [];
     const { dry, print, runInBand, jscodeshift, verbose } = options;
     if (dry) {
@@ -92,7 +96,7 @@ async function runTransform(transform, path, options) {
     if (verbose) {
         args.push('--verbose=2');
     }
-    args.push('--no-babel');
+    args.push('--parser=tsx');
     args.push('--ignore-pattern=**/node_modules/**');
     args.push('--ignore-pattern=**/.next/**');
     args.push('--extensions=tsx,ts,jsx,js');

package/lib/handle-package.js

@@ -35,6 +35,8 @@ function getPkgManager(baseDir) {
                     return 'npm';
             }
         }
+        // No lock file found, default to npm
+        return 'npm';
     }
     catch {
         return 'npm';

package/lib/utils.js

@@ -106,5 +106,15 @@ exports.TRANSFORMER_INQUIRER_CHOICES = [
         value: 'app-dir-runtime-config-experimental-edge',
         version: '15.0.0-canary.179',
     },
+    {
+        title: 'Updates `next.config.js` to use the new `turbopack` configuration',
+        value: 'next-experimental-turbo-to-turbopack',
+        version: '10.0.0',
+    },
+    {
+        title: 'Migrate from `next lint` to the ESLint CLI',
+        value: 'next-lint-to-eslint-cli',
+        version: '16.0.0',
+    },
 ];
 //# sourceMappingURL=utils.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/codemod",
-  "version": "15.4.7",
+  "version": "15.5.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/transforms/lib/utils.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNextConfigFile = isNextConfigFile;
+const node_path_1 = __importDefault(require("node:path"));
+function isNextConfigFile(file) {
+    const parsed = node_path_1.default.parse(file.path || '/');
+    return (parsed.base === 'next.config.js' ||
+        parsed.base === 'next.config.ts' ||
+        parsed.base === 'next.config.mjs' ||
+        parsed.base === 'next.config.cjs');
+}
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,204 @@
+"use strict";
+/*
+ * This codemod transforms the experimental turbo configuration in Next.js config to
+ * the new top-level `turbopack` configuration.
+ *
+ * It moves most properties from experimental.turbo to the top-level turbopack
+ * property, with special handling for certain properties like memoryLimit, minify,
+ * treeShaking, and sourceMaps which become experimental.turbopack* properties instead.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformer;
+const parser_1 = require("../lib/parser");
+const utils_1 = require("./lib/utils");
+// Properties that need to be moved to experimental.turbopack*
+const RENAMED_EXPERIMENTAL_PROPERTIES = {
+    memoryLimit: 'turbopackMemoryLimit',
+    minify: 'turbopackMinify',
+    treeShaking: 'turbopackTreeShaking',
+    sourceMaps: 'turbopackSourceMaps',
+};
+function transformer(file, _api, options) {
+    const j = (0, parser_1.createParserFromPath)(file.path);
+    const root = j(file.source);
+    let hasChanges = false;
+    if (!(0, utils_1.isNextConfigFile)(file) &&
+        process.env.NODE_ENV !== 'test' // fixtures have unique basenames in test
+    ) {
+        return file.source;
+    }
+    // Process a config object once we find it
+    function processConfigObject(configObj) {
+        // Check for `experimental` property in the config
+        const experimentalProp = configObj.properties.find((prop) => isStaticProperty(prop) &&
+            prop.key &&
+            prop.key.type === 'Identifier' &&
+            prop.key.name === 'experimental');
+        if (!experimentalProp || !isStaticProperty(experimentalProp)) {
+            return false;
+        }
+        const experimentalObj = experimentalProp.value;
+        if (experimentalObj.type !== 'ObjectExpression') {
+            return false;
+        }
+        // Check for `experimental.turbo` property in the config
+        const turboProp = experimentalObj.properties.find((prop) => isStaticProperty(prop) &&
+            prop.key &&
+            prop.key.type === 'Identifier' &&
+            prop.key.name === 'turbo');
+        if (!turboProp || !isStaticProperty(turboProp)) {
+            return false;
+        }
+        const turboObj = turboProp.value;
+        if (turboObj.type !== 'ObjectExpression') {
+            return false;
+        }
+        const regularProps = [];
+        const specialProps = [];
+        turboObj.properties.forEach((prop) => {
+            if (isStaticProperty(prop) &&
+                prop.key &&
+                prop.key.type === 'Identifier' &&
+                RENAMED_EXPERIMENTAL_PROPERTIES[prop.key.name]) {
+                // Create a new property with the renamed key
+                specialProps.push(j.objectProperty(j.identifier(RENAMED_EXPERIMENTAL_PROPERTIES[prop.key.name]), prop.value));
+            }
+            else {
+                // Keep the property for turbopack
+                regularProps.push(prop);
+            }
+        });
+        const existingProps = experimentalObj.properties.filter((prop) => !(isStaticProperty(prop) &&
+            prop.key &&
+            prop.key.type === 'Identifier' &&
+            prop.key.name === 'turbo'));
+        experimentalObj.properties = [...existingProps, ...specialProps];
+        // If experimental has no properties, remove it
+        if (experimentalObj.properties.length === 0) {
+            configObj.properties = configObj.properties.filter((prop) => !(isStaticProperty(prop) &&
+                prop.key &&
+                prop.key.type === 'Identifier' &&
+                prop.key.name === 'experimental'));
+        }
+        // Add turbopack property at top level if there are regular props
+        if (regularProps.length > 0) {
+            // Create the turbopack property
+            const turbopackProp = j.objectProperty(j.identifier('turbopack'), j.objectExpression(regularProps));
+            configObj.properties.push(turbopackProp);
+        }
+        return true;
+    }
+    root.find(j.ObjectExpression).forEach((path) => {
+        if (processConfigObject(path.value)) {
+            hasChanges = true;
+        }
+    });
+    // Transform config.experimental.turbo.X = value to config.turbopack.X = value
+    // or config.experimental.turbopackX = value for special properties
+    root
+        .find(j.AssignmentExpression, {
+        left: {
+            type: 'MemberExpression',
+            object: {
+                type: 'MemberExpression',
+                object: {
+                    type: 'MemberExpression',
+                    property: { type: 'Identifier', name: 'experimental' },
+                },
+                property: { type: 'Identifier', name: 'turbo' },
+            },
+        },
+    })
+        .forEach((path) => {
+        if (path.node.left.type !== 'MemberExpression')
+            return;
+        // Get the variable name (e.g., config in config.experimental.turbo.sourceMaps)
+        let varName = null;
+        let currentPath = path.node.left.object;
+        while (currentPath?.type === 'MemberExpression') {
+            currentPath = currentPath.object;
+        }
+        if (currentPath?.type === 'Identifier') {
+            varName = currentPath.name;
+        }
+        if (!varName)
+            return;
+        // Get the property name being assigned (e.g., sourceMaps)
+        let propName = undefined;
+        if (path.node.left.property &&
+            path.node.left.property.type === 'Identifier') {
+            propName = path.node.left.property.name;
+        }
+        else {
+            return;
+        }
+        // For special properties like memoryLimit, minify, etc.
+        if (propName && RENAMED_EXPERIMENTAL_PROPERTIES[propName]) {
+            const newAssignment = j.assignmentExpression('=', j.memberExpression(j.memberExpression(j.identifier(varName), j.identifier('experimental')), j.identifier(RENAMED_EXPERIMENTAL_PROPERTIES[propName])), path.node.right);
+            j(path).replaceWith(newAssignment);
+            hasChanges = true;
+        }
+        else if (propName) {
+            // Create new assignment: config.turbopack.propName = value
+            const newAssignment = j.assignmentExpression('=', j.memberExpression(j.memberExpression(j.identifier(varName), j.identifier('turbopack')), j.identifier(propName)), path.node.right);
+            j(path).replaceWith(newAssignment);
+            hasChanges = true;
+        }
+    });
+    // For nested property assignments like config.experimental.turbo.resolveAlias.foo = 'bar';
+    root.find(j.AssignmentExpression).forEach((path) => {
+        if (path.node.left.type !== 'MemberExpression')
+            return;
+        // Build a path to check if this is like `experimental.turbo.resolveAlias.foo`
+        let obj = path.node.left.object;
+        let props = [];
+        // Collect the property chain
+        while (obj && obj.type === 'MemberExpression') {
+            if (obj.property && obj.property.type === 'Identifier') {
+                props.unshift(obj.property.name);
+            }
+            obj = obj.object;
+        }
+        // Get the root variable name (e.g., 'config')
+        let varName = null;
+        if (obj && obj.type === 'Identifier') {
+            varName = obj.name;
+        }
+        if (!varName)
+            return;
+        // Check if this matches the pattern: config.experimental.turbo.resolveAlias.foo
+        if (props.length >= 3 &&
+            props[0] === 'experimental' &&
+            props[1] === 'turbo') {
+            // Get the final property name, only if it's an Identifier
+            let finalProp = undefined;
+            if (path.node.left.property &&
+                path.node.left.property.type === 'Identifier') {
+                finalProp = path.node.left.property.name;
+            }
+            else {
+                // If not an Identifier, skip this assignment
+                return;
+            }
+            // The properties after 'turbo'
+            const middleProps = props.slice(2); // e.g. ['resolveAlias']
+            // Start building the new left side: config.turbopack
+            let newLeft = j.memberExpression(j.identifier(varName), j.identifier('turbopack'));
+            // Add the middle properties
+            for (const prop of middleProps) {
+                newLeft = j.memberExpression(newLeft, j.identifier(prop));
+            }
+            // Add the final property
+            newLeft = j.memberExpression(newLeft, j.identifier(finalProp));
+            const newAssignment = j.assignmentExpression('=', newLeft, path.node.right);
+            j(path).replaceWith(newAssignment);
+            hasChanges = true;
+        }
+    });
+    // Only return a string if we changed the AST, otherwise return the original source
+    return hasChanges ? root.toSource(options) : file.source;
+}
+function isStaticProperty(prop) {
+    return prop.type === 'Property' || prop.type === 'ObjectProperty';
+}
+//# sourceMappingURL=next-experimental-turbo-to-turbopack.js.map

package/transforms/next-image-experimental.js

@@ -4,6 +4,7 @@ exports.default = transformer;
 const path_1 = require("path");
 const fs_1 = require("fs");
 const parser_1 = require("../lib/parser");
+const utils_1 = require("./lib/utils");
 function findAndReplaceProps(j, root, tagName) {
     const layoutToStyle = {
         intrinsic: { maxWidth: '100%', height: 'auto' },
@@ -192,14 +193,11 @@ function nextConfigTransformer(j, root, appDir) {
 function transformer(file, _api, options) {
     const j = (0, parser_1.createParserFromPath)(file.path);
     const root = j(file.source);
-    const parsed = (0, path_1.parse)(file.path || '/');
-    const isConfig = parsed.base === 'next.config.js' ||
-        parsed.base === 'next.config.ts' ||
-        parsed.base === 'next.config.mjs' ||
-        parsed.base === 'next.config.cjs';
+    const isConfig = (0, utils_1.isNextConfigFile)(file);
     if (isConfig) {
-        const result = nextConfigTransformer(j, root, parsed.dir);
-        return result.toSource();
+        const fileDir = (0, path_1.parse)(file.path).dir;
+        const result = nextConfigTransformer(j, root, fileDir);
+        return result.toSource(options);
     }
     // Before: import Image from "next/legacy/image"
     //  After: import Image from "next/image"

package/transforms/next-lint-to-eslint-cli.js

@@ -0,0 +1,710 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prefixes = void 0;
+exports.default = transformer;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const handle_package_1 = require("../lib/handle-package");
+const parser_1 = require("../lib/parser");
+const picocolors_1 = require("picocolors");
+exports.prefixes = {
+    wait: (0, picocolors_1.white)((0, picocolors_1.bold)('○')),
+    error: (0, picocolors_1.red)((0, picocolors_1.bold)('⨯')),
+    warn: (0, picocolors_1.yellow)((0, picocolors_1.bold)('⚠')),
+    ready: '▲', // no color
+    info: (0, picocolors_1.white)((0, picocolors_1.bold)(' ')),
+    event: (0, picocolors_1.green)((0, picocolors_1.bold)('✓')),
+    trace: (0, picocolors_1.magenta)((0, picocolors_1.bold)('»')),
+};
+const ESLINT_CONFIG_TEMPLATE_TYPESCRIPT = `\
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+});
+
+const eslintConfig = [
+  ...compat.extends("next/core-web-vitals", "next/typescript"),
+  {
+    ignores: [
+      "node_modules/**",
+      ".next/**",
+      "out/**",
+      "build/**",
+      "next-env.d.ts",
+    ],
+  },
+];
+
+export default eslintConfig;
+`;
+const ESLINT_CONFIG_TEMPLATE_JAVASCRIPT = `import { dirname } from "path";
+import { fileURLToPath } from "url";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+});
+
+const eslintConfig = [
+  ...compat.extends("next/core-web-vitals"),
+  {
+    ignores: [
+      "node_modules/**",
+      ".next/**",
+      "out/**",
+      "build/**",
+      "next-env.d.ts",
+    ],
+  },
+];
+
+export default eslintConfig;
+`;
+function detectTypeScript(projectRoot) {
+    return (0, node_fs_1.existsSync)(node_path_1.default.join(projectRoot, 'tsconfig.json'));
+}
+function findExistingEslintConfig(projectRoot) {
+    const flatConfigs = [
+        'eslint.config.js',
+        'eslint.config.mjs',
+        'eslint.config.cjs',
+        'eslint.config.ts',
+        'eslint.config.mts',
+        'eslint.config.cts',
+    ];
+    const legacyConfigs = [
+        '.eslintrc.js',
+        '.eslintrc.cjs',
+        '.eslintrc.yaml',
+        '.eslintrc.yml',
+        '.eslintrc.json',
+        '.eslintrc',
+    ];
+    // Check for flat configs first (preferred for v9+)
+    for (const config of flatConfigs) {
+        const configPath = node_path_1.default.join(projectRoot, config);
+        if ((0, node_fs_1.existsSync)(configPath)) {
+            return { exists: true, path: configPath, isFlat: true };
+        }
+    }
+    // Check for legacy configs
+    for (const config of legacyConfigs) {
+        const configPath = node_path_1.default.join(projectRoot, config);
+        if ((0, node_fs_1.existsSync)(configPath)) {
+            return { exists: true, path: configPath, isFlat: false };
+        }
+    }
+    return { exists: false };
+}
+function updateExistingFlatConfig(configPath, isTypeScript) {
+    let configContent;
+    try {
+        configContent = (0, node_fs_1.readFileSync)(configPath, 'utf8');
+    }
+    catch (error) {
+        console.error(`   Error reading config file: ${error}`);
+        return false;
+    }
+    // Check if Next.js configs are already imported
+    const hasNextConfigs = configContent.includes('next/core-web-vitals') ||
+        configContent.includes('next/typescript');
+    // TypeScript config files need special handling
+    if (configPath.endsWith('.ts') ||
+        configPath.endsWith('.mts') ||
+        configPath.endsWith('.cts')) {
+        console.warn(exports.prefixes.warn, '   TypeScript config files require manual migration');
+        console.log('   Please add the following to your config:');
+        console.log('   - Import: import { FlatCompat } from "@eslint/eslintrc"');
+        console.log('   - Extend: ...compat.extends("next/core-web-vitals"' +
+            (isTypeScript ? ', "next/typescript"' : '') +
+            ')');
+        return false;
+    }
+    // Parse the file using jscodeshift
+    const j = (0, parser_1.createParserFromPath)(configPath);
+    const root = j(configContent);
+    // Determine if it's CommonJS or ES modules
+    let isCommonJS = false;
+    if (configPath.endsWith('.cjs')) {
+        isCommonJS = true;
+    }
+    else if (configPath.endsWith('.mjs')) {
+        isCommonJS = false;
+    }
+    else if (configPath.endsWith('.js')) {
+        // For .js files, check package.json type field
+        const projectRoot = node_path_1.default.dirname(configPath);
+        const packageJsonPath = node_path_1.default.join(projectRoot, 'package.json');
+        try {
+            if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+                const packageJson = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, 'utf8'));
+                isCommonJS = packageJson.type !== 'module';
+            }
+            else {
+                // Default to CommonJS if no package.json found
+                isCommonJS = true;
+            }
+        }
+        catch {
+            // Default to CommonJS if package.json can't be read
+            isCommonJS = true;
+        }
+        // Always check file syntax to override package.json detection if needed
+        // This handles cases where package.json doesn't specify type but file uses ES modules
+        const hasESModuleSyntax = root.find(j.ExportDefaultDeclaration).size() > 0 ||
+            root.find(j.ExportNamedDeclaration).size() > 0 ||
+            root.find(j.ImportDeclaration).size() > 0;
+        const hasCommonJSSyntax = root
+            .find(j.AssignmentExpression, {
+            left: {
+                type: 'MemberExpression',
+                object: { name: 'module' },
+                property: { name: 'exports' },
+            },
+        })
+            .size() > 0;
+        // Override package.json detection based on actual syntax
+        if (hasESModuleSyntax && !hasCommonJSSyntax) {
+            isCommonJS = false;
+        }
+        else if (hasCommonJSSyntax && !hasESModuleSyntax) {
+            isCommonJS = true;
+        }
+        // If both or neither are found, keep the package.json-based detection
+    }
+    else {
+        // For other extensions (.ts, .mts, .cts), assume based on extension
+        isCommonJS = configPath.endsWith('.cts');
+    }
+    // Find the exported array
+    let exportedArray = null;
+    let exportNode = null;
+    if (isCommonJS) {
+        // Look for module.exports = [...]
+        const moduleExports = root.find(j.AssignmentExpression, {
+            left: {
+                type: 'MemberExpression',
+                object: { name: 'module' },
+                property: { name: 'exports' },
+            },
+            right: { type: 'ArrayExpression' },
+        });
+        if (moduleExports.size() > 0) {
+            exportNode = moduleExports.at(0);
+            exportedArray = exportNode.get('right');
+        }
+    }
+    else {
+        // Look for export default [...]
+        const defaultExports = root.find(j.ExportDefaultDeclaration, {
+            declaration: { type: 'ArrayExpression' },
+        });
+        if (defaultExports.size() > 0) {
+            exportNode = defaultExports.at(0);
+            exportedArray = exportNode.get('declaration');
+        }
+        else {
+            // Look for const variable = [...]; export default variable
+            const defaultExportIdentifier = root.find(j.ExportDefaultDeclaration, {
+                declaration: { type: 'Identifier' },
+            });
+            if (defaultExportIdentifier.size() > 0) {
+                const declarationNode = defaultExportIdentifier.at(0).get('declaration');
+                if (!declarationNode.value) {
+                    return false;
+                }
+                const varName = declarationNode.value.name;
+                const varDeclaration = root.find(j.VariableDeclarator, {
+                    id: { name: varName },
+                    init: { type: 'ArrayExpression' },
+                });
+                if (varDeclaration.size() > 0) {
+                    exportedArray = varDeclaration.at(0).get('init');
+                }
+            }
+        }
+    }
+    if (!exportedArray) {
+        console.warn(exports.prefixes.warn, '   Config does not export an array. Manual migration required.');
+        console.warn(exports.prefixes.warn, '   ESLint flat configs must export an array of configuration objects.');
+        return false;
+    }
+    // Check if FlatCompat is already imported
+    const hasFlatCompat = isCommonJS
+        ? root
+            .find(j.CallExpression, {
+            callee: { name: 'require' },
+            arguments: [{ value: '@eslint/eslintrc' }],
+        })
+            .size() > 0
+        : root
+            .find(j.ImportDeclaration, {
+            source: { value: '@eslint/eslintrc' },
+        })
+            .size() > 0;
+    // Add necessary imports if not present and if we're adding Next.js extends
+    if (!hasFlatCompat && !hasNextConfigs) {
+        if (isCommonJS) {
+            // Add CommonJS requires at the top
+            const firstNode = root.find(j.Program).get('body', 0);
+            const compatRequire = j.variableDeclaration('const', [
+                j.variableDeclarator(j.objectPattern([
+                    j.property('init', j.identifier('FlatCompat'), j.identifier('FlatCompat')),
+                ]), j.callExpression(j.identifier('require'), [
+                    j.literal('@eslint/eslintrc'),
+                ])),
+            ]);
+            const pathRequire = j.variableDeclaration('const', [
+                j.variableDeclarator(j.identifier('path'), j.callExpression(j.identifier('require'), [j.literal('path')])),
+            ]);
+            const compatNew = j.variableDeclaration('const', [
+                j.variableDeclarator(j.identifier('compat'), j.newExpression(j.identifier('FlatCompat'), [
+                    j.objectExpression([
+                        j.property('init', j.identifier('baseDirectory'), j.identifier('__dirname')),
+                    ]),
+                ])),
+            ]);
+            j(firstNode).insertBefore(compatRequire);
+            j(firstNode).insertBefore(pathRequire);
+            j(firstNode).insertBefore(compatNew);
+        }
+        else {
+            // Add ES module imports
+            const firstImport = root.find(j.ImportDeclaration).at(0);
+            const insertPoint = firstImport.size() > 0
+                ? firstImport
+                : root.find(j.Program).get('body', 0);
+            const imports = [
+                j.importDeclaration([j.importSpecifier(j.identifier('dirname'))], j.literal('path')),
+                j.importDeclaration([j.importSpecifier(j.identifier('fileURLToPath'))], j.literal('url')),
+                j.importDeclaration([j.importSpecifier(j.identifier('FlatCompat'))], j.literal('@eslint/eslintrc')),
+            ];
+            const setupVars = [
+                j.variableDeclaration('const', [
+                    j.variableDeclarator(j.identifier('__filename'), j.callExpression(j.identifier('fileURLToPath'), [
+                        j.memberExpression(j.memberExpression(j.identifier('import'), j.identifier('meta')), j.identifier('url')),
+                    ])),
+                ]),
+                j.variableDeclaration('const', [
+                    j.variableDeclarator(j.identifier('__dirname'), j.callExpression(j.identifier('dirname'), [
+                        j.identifier('__filename'),
+                    ])),
+                ]),
+                j.variableDeclaration('const', [
+                    j.variableDeclarator(j.identifier('compat'), j.newExpression(j.identifier('FlatCompat'), [
+                        j.objectExpression([
+                            j.property('init', j.identifier('baseDirectory'), j.identifier('__dirname')),
+                        ]),
+                    ])),
+                ]),
+            ];
+            if (firstImport.size() > 0) {
+                // Insert after the last import
+                const lastImportPath = root.find(j.ImportDeclaration).at(-1).get();
+                if (!lastImportPath) {
+                    // Fallback to inserting at the beginning
+                    const fallbackInsertPoint = root.find(j.Program).get('body', 0);
+                    imports.forEach((imp) => j(fallbackInsertPoint).insertBefore(imp));
+                    setupVars.forEach((v) => j(fallbackInsertPoint).insertBefore(v));
+                }
+                else {
+                    imports.forEach((imp) => j(lastImportPath).insertAfter(imp));
+                    setupVars.forEach((v) => j(lastImportPath).insertAfter(v));
+                }
+            }
+            else {
+                // Insert at the beginning
+                imports.forEach((imp) => j(insertPoint).insertBefore(imp));
+                setupVars.forEach((v) => j(insertPoint).insertBefore(v));
+            }
+        }
+    }
+    // Create ignores configuration object
+    const ignoresConfig = j.objectExpression([
+        j.property('init', j.identifier('ignores'), j.arrayExpression([
+            j.literal('node_modules/**'),
+            j.literal('.next/**'),
+            j.literal('out/**'),
+            j.literal('build/**'),
+            j.literal('next-env.d.ts'),
+        ])),
+    ]);
+    // Only add Next.js extends if they're not already present
+    if (!hasNextConfigs) {
+        // Add Next.js configs to the array
+        const nextExtends = isTypeScript
+            ? ['next/core-web-vitals', 'next/typescript']
+            : ['next/core-web-vitals'];
+        const spreadElement = j.spreadElement(j.callExpression(j.memberExpression(j.identifier('compat'), j.identifier('extends')), nextExtends.map((ext) => j.literal(ext))));
+        // Insert Next.js extends at the beginning of the array
+        if (!exportedArray.value.elements) {
+            exportedArray.value.elements = [];
+        }
+        exportedArray.value.elements.unshift(spreadElement);
+    }
+    // Check if ignores already exist in the config and merge if needed
+    let existingIgnoresIndex = -1;
+    if (exportedArray.value.elements) {
+        for (let i = 0; i < exportedArray.value.elements.length; i++) {
+            const element = exportedArray.value.elements[i];
+            if (element &&
+                element.type === 'ObjectExpression' &&
+                element.properties &&
+                element.properties.some((prop) => prop.type === 'Property' &&
+                    prop.key &&
+                    prop.key.type === 'Identifier' &&
+                    prop.key.name === 'ignores')) {
+                existingIgnoresIndex = i;
+                break;
+            }
+        }
+    }
+    if (existingIgnoresIndex === -1) {
+        // No existing ignores, add our own at appropriate position
+        const insertIndex = hasNextConfigs ? 0 : 1;
+        exportedArray.value.elements.splice(insertIndex, 0, ignoresConfig);
+    }
+    else {
+        // Merge with existing ignores
+        const existingIgnoresArr = exportedArray.value.elements[existingIgnoresIndex]?.properties ?? [];
+        const ignoresProp = existingIgnoresArr.find((prop) => prop.type === 'Property' &&
+            prop.key &&
+            prop.key.type === 'Identifier' &&
+            prop.key.name === 'ignores');
+        if (ignoresProp &&
+            ignoresProp.value &&
+            ignoresProp.value.type === 'ArrayExpression') {
+            // Add our ignores to the existing array if they're not already there
+            const nextIgnores = [
+                'node_modules/**',
+                '.next/**',
+                'out/**',
+                'build/**',
+                'next-env.d.ts',
+            ];
+            const existingIgnores = ignoresProp.value.elements
+                .map((el) => (el.type === 'Literal' ? el.value : null))
+                .filter(Boolean);
+            for (const ignore of nextIgnores) {
+                if (!existingIgnores.includes(ignore)) {
+                    ignoresProp.value.elements.push(j.literal(ignore));
+                }
+            }
+        }
+    }
+    // Generate the updated code
+    const updatedContent = root.toSource();
+    if (updatedContent !== configContent) {
+        try {
+            (0, node_fs_1.writeFileSync)(configPath, updatedContent);
+        }
+        catch (error) {
+            console.error(`   Error writing config file: ${error}`);
+            return false;
+        }
+        if (hasNextConfigs) {
+            console.log(`   Updated ${node_path_1.default.basename(configPath)} with Next.js ignores configuration`);
+        }
+        else {
+            console.log(`   Updated ${node_path_1.default.basename(configPath)} with Next.js ESLint configs`);
+        }
+        return true;
+    }
+    // If nothing changed but Next.js configs were already present, that's still success
+    if (hasNextConfigs) {
+        console.log('   Next.js ESLint configs already present in flat config');
+        return true;
+    }
+    return false;
+}
+function updatePackageJsonScripts(packageJsonContent) {
+    try {
+        const packageJson = JSON.parse(packageJsonContent);
+        let needsUpdate = false;
+        if (!packageJson.scripts) {
+            packageJson.scripts = {};
+        }
+        // Process all scripts that contain "next lint"
+        for (const scriptName in packageJson.scripts) {
+            const scriptValue = packageJson.scripts[scriptName];
+            if (typeof scriptValue === 'string' &&
+                scriptValue.includes('next lint')) {
+                // Replace "next lint" with "eslint" and handle special arguments
+                const updatedScript = scriptValue.replace(/\bnext\s+lint\b([^&|;]*)/gi, (_match, args = '') => {
+                    // Track whether we need a trailing space before operators
+                    let trailingSpace = '';
+                    if (args.endsWith(' ')) {
+                        trailingSpace = ' ';
+                        args = args.trimEnd();
+                    }
+                    // Check for redirects (2>, 1>, etc.) and preserve them
+                    let redirect = '';
+                    const redirectMatch = args.match(/\s+(\d*>[>&]?.*)$/);
+                    if (redirectMatch) {
+                        redirect = ` ${redirectMatch[1]}`;
+                        args = args.substring(0, redirectMatch.index);
+                    }
+                    // Parse arguments - handle quoted strings properly
+                    const argTokens = [];
+                    let current = '';
+                    let inQuotes = false;
+                    let quoteChar = '';
+                    for (let j = 0; j < args.length; j++) {
+                        const char = args[j];
+                        if ((char === '"' || char === "'") &&
+                            (j === 0 || args[j - 1] !== '\\')) {
+                            if (!inQuotes) {
+                                inQuotes = true;
+                                quoteChar = char;
+                                current += char;
+                            }
+                            else if (char === quoteChar) {
+                                inQuotes = false;
+                                quoteChar = '';
+                                current += char;
+                            }
+                            else {
+                                current += char;
+                            }
+                        }
+                        else if (char === ' ' && !inQuotes) {
+                            if (current) {
+                                argTokens.push(current);
+                                current = '';
+                            }
+                        }
+                        else {
+                            current += char;
+                        }
+                    }
+                    if (current) {
+                        argTokens.push(current);
+                    }
+                    const eslintArgs = [];
+                    const paths = [];
+                    for (let i = 0; i < argTokens.length; i++) {
+                        const token = argTokens[i];
+                        if (token === '--strict') {
+                            eslintArgs.push('--max-warnings', '0');
+                        }
+                        else if (token === '--dir' && i + 1 < argTokens.length) {
+                            paths.push(argTokens[++i]);
+                        }
+                        else if (token === '--file' && i + 1 < argTokens.length) {
+                            paths.push(argTokens[++i]);
+                        }
+                        else if (token === '--rulesdir' && i + 1 < argTokens.length) {
+                            // Skip rulesdir and its value
+                            i++;
+                        }
+                        else if (token === '--ext' && i + 1 < argTokens.length) {
+                            // Skip ext and its value
+                            i++;
+                        }
+                        else if (token.startsWith('--')) {
+                            // Keep other flags and their values
+                            eslintArgs.push(token);
+                            if (i + 1 < argTokens.length &&
+                                !argTokens[i + 1].startsWith('--')) {
+                                eslintArgs.push(argTokens[++i]);
+                            }
+                        }
+                        else {
+                            // Positional arguments (paths)
+                            paths.push(token);
+                        }
+                    }
+                    // Build the result
+                    let result = 'eslint';
+                    if (eslintArgs.length > 0) {
+                        result += ` ${eslintArgs.join(' ')}`;
+                    }
+                    // Add paths or default to .
+                    if (paths.length > 0) {
+                        result += ` ${paths.join(' ')}`;
+                    }
+                    else {
+                        result += ' .';
+                    }
+                    // Add redirect if present
+                    result += redirect;
+                    // Add back trailing space if we had one
+                    result += trailingSpace;
+                    return result;
+                });
+                if (updatedScript !== scriptValue) {
+                    packageJson.scripts[scriptName] = updatedScript;
+                    needsUpdate = true;
+                    console.log(`   Updated script "${scriptName}": "${scriptValue}" → "${updatedScript}"`);
+                    // Note about unsupported flags
+                    if (scriptValue.includes('--rulesdir')) {
+                        console.log(`   Note: --rulesdir is not supported in ESLint v9`);
+                    }
+                    if (scriptValue.includes('--ext')) {
+                        console.log(`   Note: --ext is not needed in ESLint v9 flat config`);
+                    }
+                }
+            }
+        }
+        // Ensure required devDependencies exist
+        if (!packageJson.devDependencies) {
+            packageJson.devDependencies = {};
+        }
+        // Check if eslint exists in either dependencies or devDependencies
+        if (!packageJson.devDependencies.eslint &&
+            !packageJson.dependencies?.eslint) {
+            packageJson.devDependencies.eslint = '^9';
+            needsUpdate = true;
+        }
+        // Check if eslint-config-next exists in either dependencies or devDependencies
+        if (!packageJson.devDependencies['eslint-config-next'] &&
+            !packageJson.dependencies?.['eslint-config-next']) {
+            // Use the same version as next if available
+            const nextVersion = packageJson.dependencies?.next || packageJson.devDependencies?.next;
+            packageJson.devDependencies['eslint-config-next'] =
+                nextVersion || 'latest';
+            needsUpdate = true;
+        }
+        // Check if @eslint/eslintrc exists in either dependencies or devDependencies
+        if (!packageJson.devDependencies['@eslint/eslintrc'] &&
+            !packageJson.dependencies?.['@eslint/eslintrc']) {
+            packageJson.devDependencies['@eslint/eslintrc'] = '^3';
+            needsUpdate = true;
+        }
+        const updatedContent = `${JSON.stringify(packageJson, null, 2)}\n`;
+        return { updated: needsUpdate, content: updatedContent };
+    }
+    catch (error) {
+        console.error('Error updating package.json:', error);
+        return { updated: false, content: packageJsonContent };
+    }
+}
+function transformer(files, options = {}) {
+    // The codemod CLI passes arguments as an array for consistency with file-based transforms,
+    // but project-level transforms like this one only process a single directory.
+    // Usage: npx @next/codemod next-lint-to-eslint-cli <project-directory>
+    const dir = files[0];
+    if (!dir) {
+        console.error('Error: Please specify a directory path');
+        return;
+    }
+    // Allow skipping installation via option
+    const skipInstall = options.skipInstall === true;
+    const projectRoot = node_path_1.default.resolve(dir);
+    const packageJsonPath = node_path_1.default.join(projectRoot, 'package.json');
+    if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
+        console.error('Error: package.json not found in the specified directory');
+        return;
+    }
+    const isTypeScript = detectTypeScript(projectRoot);
+    console.log('Migrating from next lint to the ESLint CLI...');
+    // Check for existing ESLint config
+    const existingConfig = findExistingEslintConfig(projectRoot);
+    if (existingConfig.exists) {
+        if (existingConfig.isFlat) {
+            // Try to update existing flat config
+            if (existingConfig.path) {
+                console.log(`   Found existing flat config: ${node_path_1.default.basename(existingConfig.path)}`);
+                const updated = updateExistingFlatConfig(existingConfig.path, isTypeScript);
+                if (!updated) {
+                    console.log('   Could not automatically update the existing flat config.');
+                    console.log('   Please manually ensure your ESLint config extends "next/core-web-vitals"');
+                    if (isTypeScript) {
+                        console.log('   and "next/typescript" for TypeScript projects.');
+                    }
+                }
+            }
+        }
+        else {
+            // Legacy config exists
+            if (existingConfig.path) {
+                console.log(`   Found legacy ESLint config: ${node_path_1.default.basename(existingConfig.path)}`);
+                console.log('   Legacy .eslintrc configs are not automatically migrated.');
+                console.log('   Please migrate to flat config format (eslint.config.js) and ensure it extends:');
+                console.log('   - "next/core-web-vitals"');
+                if (isTypeScript) {
+                    console.log('   - "next/typescript"');
+                }
+                console.log('   Learn more: https://eslint.org/docs/latest/use/configure/migration-guide');
+            }
+        }
+    }
+    else {
+        // Create new ESLint flat config
+        const eslintConfigPath = node_path_1.default.join(projectRoot, 'eslint.config.mjs');
+        const template = isTypeScript
+            ? ESLINT_CONFIG_TEMPLATE_TYPESCRIPT
+            : ESLINT_CONFIG_TEMPLATE_JAVASCRIPT;
+        try {
+            (0, node_fs_1.writeFileSync)(eslintConfigPath, template);
+            console.log(`   Created ${node_path_1.default.basename(eslintConfigPath)}`);
+        }
+        catch (error) {
+            console.error('   Error creating ESLint config:', error);
+        }
+    }
+    // Update package.json
+    const packageJsonContent = (0, node_fs_1.readFileSync)(packageJsonPath, 'utf8');
+    const result = updatePackageJsonScripts(packageJsonContent);
+    if (result.updated) {
+        try {
+            (0, node_fs_1.writeFileSync)(packageJsonPath, result.content);
+            console.log('Updated package.json scripts and dependencies');
+            // Parse the updated package.json to find new dependencies
+            const updatedPackageJson = JSON.parse(result.content);
+            const originalPackageJson = JSON.parse(packageJsonContent);
+            const newDependencies = [];
+            // Check for new devDependencies
+            if (updatedPackageJson.devDependencies) {
+                for (const [pkg, version] of Object.entries(updatedPackageJson.devDependencies)) {
+                    if (!originalPackageJson.devDependencies?.[pkg] &&
+                        !originalPackageJson.dependencies?.[pkg]) {
+                        newDependencies.push(`${pkg}@${version}`);
+                    }
+                }
+            }
+            // Install new dependencies if any were added
+            if (newDependencies.length > 0) {
+                if (skipInstall) {
+                    console.log('\nNew dependencies added to package.json:');
+                    newDependencies.forEach((dep) => console.log(`   - ${dep}`));
+                    console.log(`Please run: ${(0, handle_package_1.getPkgManager)(projectRoot)} install`);
+                }
+                else {
+                    console.log('\nInstalling new dependencies...');
+                    try {
+                        const packageManager = (0, handle_package_1.getPkgManager)(projectRoot);
+                        console.log(`   Using ${packageManager}...`);
+                        (0, handle_package_1.installPackages)(newDependencies, {
+                            packageManager,
+                            dev: true,
+                            silent: false,
+                        });
+                        console.log('   Dependencies installed successfully!');
+                    }
+                    catch (_error) {
+                        console.error('   Failed to install dependencies automatically.');
+                        console.error(`   Please run: ${(0, handle_package_1.getPkgManager)(projectRoot)} install`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error writing package.json:', error);
+        }
+    }
+    console.log('\nMigration complete! Your project now uses the ESLint CLI.');
+}
+//# sourceMappingURL=next-lint-to-eslint-cli.js.map