@uniformdev/next-app-router-upgrade 0.0.0-stage → 0.1.0

package/src/scan.js

@@ -0,0 +1,443 @@
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+
+import {
+  REMOVED_CONFIG_KEYS,
+  REMOVED_EXPORTS,
+  REMOVED_OPTIONS,
+  REMOVED_PAGE_STATE_FIELDS,
+  RULES,
+} from "./rules.js";
+
+const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"]);
+const SKIP_DIRS = new Set(["node_modules", ".next", ".git", "dist", "build", "out", "coverage", ".vercel", ".turbo"]);
+const SDK = "@uniformdev/next-app-router";
+const RESOLVERS = new Set(["resolveRouteFromCode", "resolvePlaygroundRoute"]);
+const LITE_MIDDLEWARE = new Set(["uniformMiddleware", "handleUniformRoute"]);
+const MIN_NEXT = [16, 0, 7];
+
+/**
+ * Scans the project at `root` and returns { project, findings }.
+ * `contents` maps absolute file paths to text that replaces the file on disk. The migration uses it
+ * to scan its result before it writes the files.
+ */
+export function scanProject(root, { uniformDataDir, contents } = {}) {
+  const findings = [];
+  const add = (rule, details) => findings.push({ rule, ...RULES[rule], ...details });
+  const read = (file) => contents?.get(file) ?? fs.readFileSync(file, "utf8");
+
+  const pkg = readPackageJson(root, read);
+  const deps = { ...pkg?.dependencies, ...pkg?.devDependencies };
+  const project = {
+    root,
+    name: pkg?.name,
+    sdkVersion: deps[SDK],
+    usesV1: Boolean(deps["@uniformdev/canvas-next-rsc"]),
+    filesScanned: 0,
+    compositionsWithPersonalization: 0,
+  };
+
+  checkPackageJson(pkg, deps, add);
+
+  const files = listSourceFiles(root);
+  project.filesScanned = files.length;
+  const state = { usesLiteMiddleware: false, importsVercelFunctions: [] };
+  for (const file of files) {
+    scanSourceFile(root, file, add, state, read);
+  }
+
+  if (state.importsVercelFunctions.length && !deps["@vercel/functions"]) {
+    for (const where of state.importsVercelFunctions) {
+      add("vercel-functions-transitive", {
+        ...where,
+        message: "The app imports @vercel/functions, but package.json does not list it. Version 20.82 installed it as a dependency of the SDK. The developer preview makes it an optional peer dependency.",
+        fix: "Add @vercel/functions to the dependencies in package.json.",
+      });
+    }
+  }
+
+  scanUniformData(root, uniformDataDir, project, add);
+  scanNotFoundRoutes(root, files, add);
+
+  if (state.usesLiteMiddleware) {
+    const count = project.compositionsWithPersonalization;
+    add("lite-mode-flicker", {
+      ...state.liteMiddlewareLocation,
+      message:
+        "Version 20.82 chose personalization and test variants in the middleware. With uniformMiddleware or handleUniformRoute, the developer preview renders the default variants on the server, and the browser changes them after hydration." +
+        (count ? ` The uniform-data folder has ${count} composition(s) with a personalization or a test.` : ""),
+      fix: "No code change is required. To keep the first paint correct, change to vercelUniformEdgeMiddleware (edge mode).",
+    });
+  }
+
+  if (project.sdkVersion) {
+    add("not-found-html", {
+      message:
+        "Version 20.82 rewrote missing routes to /404 in the middleware. The developer preview calls notFound() while the page renders. The response is still 404, but Next.js sends an empty HTML shell, and the 404 content (also app/not-found.tsx) shows only after hydration. Tested with Next.js 16.2.10 and 16.4.0.",
+      fix: "No code change is required. Visitors without JavaScript see an empty 404 page.",
+    });
+    add("redirect-status", {
+      message: "The page applies Uniform redirects. A 301 or 308 redirect gives a 308, and other redirects give a 307. A missing route gives notFound().",
+      fix: "No change is required.",
+    });
+  }
+
+  return { project, findings };
+}
+
+function readPackageJson(root, read = (file) => fs.readFileSync(file, "utf8")) {
+  try {
+    return JSON.parse(read(path.join(root, "package.json")));
+  } catch {
+    return undefined;
+  }
+}
+
+function parseVersion(range) {
+  const match = /(\d+)\.(\d+)\.(\d+)/.exec(range ?? "");
+  return match ? match.slice(1, 4).map(Number) : undefined;
+}
+
+function isLower(a, b) {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] !== b[i]) return a[i] < b[i];
+  }
+  return false;
+}
+
+function checkPackageJson(pkg, deps, add) {
+  if (!pkg) return;
+  const where = { file: "package.json" };
+
+  const next = parseVersion(deps.next);
+  if (next && isLower(next, MIN_NEXT)) {
+    add("next-version", {
+      ...where,
+      message: `package.json has next ${deps.next}. The developer preview requires Next.js 16.0.7 or later.`,
+      fix: "Upgrade Next.js to 16.0.7 or later.",
+    });
+  }
+
+  // @uniformdev/toolbar-* and @uniformdev/context-edge have their own version lines.
+  const uniform = Object.entries(deps).filter(
+    ([name]) => name.startsWith("@uniformdev/") && !name.startsWith("@uniformdev/toolbar") && name !== "@uniformdev/context-edge"
+  );
+  const versions = new Set(uniform.map(([, version]) => version));
+  if (versions.size > 1) {
+    add("uniform-version-mismatch", {
+      ...where,
+      message: `The @uniformdev packages have different versions: ${uniform.map(([n, v]) => `${n}@${v}`).join(", ")}. Different versions can install two copies of @uniformdev/context.`,
+      fix: "Install all @uniformdev packages with the same version.",
+    });
+  }
+
+  if (deps["@uniformdev/toolbar-react"] && !pkg.overrides?.["@uniformdev/context"]) {
+    add("prerelease-peer-range", {
+      ...where,
+      message: "@uniformdev/toolbar-react has the peer range @uniformdev/context ^20.72. That range does not accept prerelease versions, so npm shows ERESOLVE for a developer preview version. A stable release is not affected.",
+      fix: 'For a prerelease version, add "overrides": { "@uniformdev/context": "$@uniformdev/context" } to package.json.',
+    });
+  }
+
+  if (deps["@uniformdev/context-edge"]) {
+    add("context-edge-dependency", {
+      ...where,
+      message: "The edge and vercel entry points of @uniformdev/next-app-router contain @uniformdev/context-edge.",
+      fix: "You can remove @uniformdev/context-edge from package.json, if the app does not import it.",
+    });
+  }
+}
+
+export function listSourceFiles(root) {
+  const out = [];
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) walk(path.join(dir, entry.name));
+      } else if (SOURCE_EXTENSIONS.has(path.extname(entry.name)) && !entry.name.endsWith(".d.ts")) {
+        out.push(path.join(dir, entry.name));
+      }
+    }
+  };
+  walk(root);
+  return out.sort();
+}
+
+export function scriptKind(file) {
+  const ext = path.extname(file);
+  if (ext === ".tsx") return ts.ScriptKind.TSX;
+  if (ext === ".jsx") return ts.ScriptKind.JSX;
+  if (ext === ".ts" || ext === ".mts" || ext === ".cts") return ts.ScriptKind.TS;
+  return ts.ScriptKind.JS;
+}
+
+function scanSourceFile(root, file, add, state, read) {
+  const text = read(file);
+  const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, scriptKind(file));
+  const rel = path.relative(root, file);
+  const at = (node) => ({ file: rel, line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1 });
+
+  const isConfigFile = /^uniform\.server\.config\.[cm]?[jt]s$/.test(path.basename(file));
+  const isMiddlewareFile = /^(src\/)?(middleware|proxy)\.[cm]?[jt]s$/.test(rel.split(path.sep).join("/"));
+
+  // Local names of SDK imports: local name -> { module, imported }.
+  const sdkLocals = new Map();
+  const sdkNamespaces = new Map();
+  let importsSdk = false;
+
+  for (const statement of sf.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    const module = statement.moduleSpecifier.text;
+
+    if (module === "@vercel/functions" || module.startsWith("@vercel/functions/")) {
+      state.importsVercelFunctions.push(at(statement));
+    }
+    if (!module.startsWith(SDK)) continue;
+    importsSdk = true;
+
+    if (module === `${SDK}/cache`) {
+      add("cached-resolver", {
+        ...at(statement),
+        message: "The resolvers of @uniformdev/next-app-router/cache now use 'use cache' only for published content. Draft and editor requests are not cached.",
+        fix: "No change is required.",
+      });
+    }
+
+    const bindings = statement.importClause?.namedBindings;
+    if (bindings && ts.isNamespaceImport(bindings)) {
+      sdkNamespaces.set(bindings.name.text, module);
+    }
+    if (bindings && ts.isNamedImports(bindings)) {
+      for (const element of bindings.elements) {
+        const imported = (element.propertyName ?? element.name).text;
+        sdkLocals.set(element.name.text, { module, imported });
+        checkImportedName(module, imported, element, add, at, state);
+      }
+    }
+  }
+
+  if (isConfigFile) importsSdk = true;
+
+  const resultVariables = new Set();
+
+  const visit = (node) => {
+    // ns.removedExport
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression)) {
+      const module = sdkNamespaces.get(node.expression.text);
+      if (module) checkImportedName(module, node.name.text, node, add, at, state);
+    }
+
+    // Removed options: { dataClient } and { pathPatternsWithVariations }.
+    if (importsSdk && (ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node))) {
+      const name = propertyName(node.name);
+      if (name && REMOVED_OPTIONS[name]) {
+        add("removed-option", { ...at(node), message: `The option "${name}" is removed.`, fix: REMOVED_OPTIONS[name] });
+      }
+      if (name && REMOVED_CONFIG_KEYS[name] && (isConfigFile || isServerConfigContext(node))) {
+        add("removed-config-key", { ...at(node), message: `The server configuration option "${name}" is removed.`, fix: REMOVED_CONFIG_KEYS[name] });
+      }
+      if (name === "defaultConsent" && isMiddlewareFile && !isBooleanLiteral(node)) {
+        add("per-request-consent", {
+          ...at(node),
+          message: "The middleware writes the default consent into the page code. Each value makes a different cached page.",
+          fix: "If you use createUniformStaticParams, list each value in its defaultConsent option.",
+        });
+      }
+    }
+
+    // <UniformComposition dataClient={...} />
+    if (ts.isJsxAttribute(node) && importsSdk) {
+      const name = node.name.getText(sf);
+      if (REMOVED_OPTIONS[name]) {
+        add("removed-option", { ...at(node), message: `The prop "${name}" is removed.`, fix: REMOVED_OPTIONS[name] });
+      }
+    }
+
+    // pageState.components and the other removed fields.
+    if (ts.isPropertyAccessExpression(node) && REMOVED_PAGE_STATE_FIELDS.includes(node.name.text)) {
+      if (endsWithPageState(node.expression)) {
+        add("removed-page-state-field", {
+          ...at(node),
+          message: `pageState.${node.name.text} is removed. The page code no longer contains evaluation results.`,
+          fix: node.name.text === "quirks" ? "Read quirks in the browser with useQuirks()." : "No replacement.",
+        });
+      }
+    }
+    if (ts.isVariableDeclaration(node) && ts.isObjectBindingPattern(node.name) && node.initializer && endsWithPageState(node.initializer)) {
+      for (const element of node.name.elements) {
+        const name = (element.propertyName ?? element.name).getText(sf);
+        if (REMOVED_PAGE_STATE_FIELDS.includes(name)) {
+          add("removed-page-state-field", { ...at(element), message: `pageState.${name} is removed.`, fix: "No replacement." });
+        }
+      }
+    }
+
+    // const result = await resolveRouteFromCode(...); result.code
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
+      const call = unwrapAwait(node.initializer);
+      if (call && ts.isCallExpression(call) && ts.isIdentifier(call.expression)) {
+        const local = sdkLocals.get(call.expression.text);
+        if (local && RESOLVERS.has(local.imported)) resultVariables.add(node.name.text);
+      }
+    }
+    const isResolverCall = (expression) => {
+      const call = unwrapAwait(expression);
+      if (!call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression)) return false;
+      return RESOLVERS.has(sdkLocals.get(call.expression.text)?.imported);
+    };
+    if (
+      ts.isPropertyAccessExpression(node) &&
+      node.name.text === "code" &&
+      ((ts.isIdentifier(node.expression) && resultVariables.has(node.expression.text)) || isResolverCall(node.expression))
+    ) {
+      add("result-code", { ...at(node), message: "ResolvedRouteResult no longer has a code field.", fix: "Keep the code from the [code] route parameter." });
+    }
+
+    // result.route.compositionApiResponse without a type check.
+    if (importsSdk && ts.isPropertyAccessExpression(node) && node.name.text === "compositionApiResponse") {
+      const target = node.expression;
+      if (ts.isPropertyAccessExpression(target) && target.name.text === "route" && !isNarrowedToComposition(node)) {
+        add("route-union", {
+          ...at(node),
+          message: "result.route can now also be a redirect, so TypeScript does not accept route.compositionApiResponse without a check.",
+          fix: 'Check result.route?.type === "composition" first, or call requireComposition(result).',
+        });
+      }
+    }
+
+    // Hard-coded old page codes.
+    if ((ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) && /(^|\/)2~\d+~/.test(node.text)) {
+      add("old-page-code", { ...at(node), message: `The string "${node.text.slice(0, 60)}" has a page code in the old format. Old codes do not work.`, fix: "Link to the path of the page, not to /uniform/<code>." });
+    }
+
+    // Lite middleware.
+    if (isMiddlewareFile && ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      const local = sdkLocals.get(node.expression.text);
+      if (local && local.module === `${SDK}/middleware` && LITE_MIDDLEWARE.has(local.imported)) {
+        state.usesLiteMiddleware = true;
+        state.liteMiddlewareLocation ??= at(node);
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+}
+
+function checkImportedName(module, imported, node, add, at) {
+  const removed = REMOVED_EXPORTS[module]?.[imported];
+  if (removed) {
+    add("removed-export", { ...at(node), message: `"${imported}" is no longer exported from ${module}.`, fix: removed });
+  }
+  if ((imported === "PersonalizeProps" || imported === "TestProps") && module.startsWith(SDK)) {
+    add("placement-props", {
+      ...at(node),
+      message: `${imported} changed: indexes is now defaultIndexes, index is now defaultIndex, and PersonalizeProps has a new personalization prop.`,
+      fix: "Update the custom placement component.",
+    });
+  }
+  if (imported === "createUniformStaticParams" || imported === "createUniformPlaygroundStaticParams") {
+    add("static-params", {
+      ...at(node),
+      message: `${imported} now makes one code for each path (and each defaultConsent and edgeMode value), not one for each variant combination.`,
+      fix: "No change is required. With edge mode, use edgeMode: [true, false].",
+    });
+  }
+}
+
+function propertyName(name) {
+  if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+  return undefined;
+}
+
+function isBooleanLiteral(node) {
+  return ts.isPropertyAssignment(node) && (node.initializer.kind === ts.SyntaxKind.TrueKeyword || node.initializer.kind === ts.SyntaxKind.FalseKeyword);
+}
+
+function isServerConfigContext(node) {
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (ts.isVariableDeclaration(parent) && parent.type && /UniformServerConfig/.test(parent.type.getText())) return true;
+    if (ts.isSatisfiesExpression?.(parent) && /UniformServerConfig/.test(parent.type.getText())) return true;
+  }
+  return false;
+}
+
+function endsWithPageState(expression) {
+  if (ts.isIdentifier(expression)) return expression.text === "pageState";
+  if (ts.isPropertyAccessExpression(expression)) return expression.name.text === "pageState";
+  return false;
+}
+
+function unwrapAwait(expression) {
+  let current = expression;
+  while (current && (ts.isAwaitExpression(current) || ts.isParenthesizedExpression(current))) current = current.expression;
+  return current;
+}
+
+// True when an enclosing if statement or conditional checks `.type === "composition"`.
+function isNarrowedToComposition(node) {
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    const condition = ts.isIfStatement(parent) || ts.isConditionalExpression(parent) ? parent.expression ?? parent.condition : undefined;
+    if (condition && /\.type\s*===?\s*["']composition["']/.test(condition.getText())) return true;
+    if (ts.isFunctionLike(parent)) {
+      const body = parent.body?.getText() ?? "";
+      if (/requireComposition\(/.test(body) || /\.type\s*!==?\s*["']composition["']/.test(body)) return true;
+    }
+  }
+  return false;
+}
+
+function scanUniformData(root, uniformDataDir, project, add) {
+  const dir = path.resolve(root, uniformDataDir ?? "uniform-data");
+  if (!fs.existsSync(dir)) return;
+
+  const readYaml = (sub) => {
+    const folder = path.join(dir, sub);
+    if (!fs.existsSync(folder)) return [];
+    return fs
+      .readdirSync(folder)
+      .filter((f) => /\.(ya?ml|json)$/.test(f))
+      .map((f) => ({ file: path.relative(root, path.join(folder, f)), text: fs.readFileSync(path.join(folder, f), "utf8") }));
+  };
+
+  for (const { file, text } of readYaml("projectMapNode")) {
+    if (/queryStrings\s*:/.test(text) && !/queryStrings\s*:\s*\[\s*\]/.test(text)) {
+      add("project-map-query-strings", {
+        file,
+        message: "This project map node declares query strings. The developer preview middleware no longer reads them, and removes all query strings from the route path.",
+        fix: "List the query strings in the queryStrings option of the middleware.",
+      });
+    }
+  }
+
+  let withViz = 0;
+  for (const { text } of [...readYaml("composition"), ...readYaml("compositionPattern"), ...readYaml("componentPattern")]) {
+    if (/\$personalization|\$test\b/.test(text)) project.compositionsWithPersonalization++;
+    if (/\$viz/.test(text)) withViz++;
+  }
+  if (withViz) {
+    add("visibility-rules", {
+      file: path.relative(root, dir),
+      message: `${withViz} composition(s) or pattern(s) use visibility rules. These components render only in the browser, so they are not in the server HTML.`,
+      fix: "Do not put content for search engines in components with visibility rules.",
+    });
+  }
+}
+
+function scanNotFoundRoutes(root, files, add) {
+  const notFoundRoutes = files.filter((f) => /(^|\/)app\/(.*\/)?404\/page\.[jt]sx?$/.test(path.relative(root, f).split(path.sep).join("/")));
+  for (const file of notFoundRoutes) {
+    add("not-found-page", {
+      file: path.relative(root, file),
+      message: "Version 20.82 rewrote missing routes to /404. The developer preview calls notFound() on the page, so this route no longer renders for missing pages.",
+      fix: "Move the 404 content to app/not-found.tsx.",
+    });
+  }
+}

package/src/session.js

@@ -0,0 +1,194 @@
+// The migration flow, shared by `migrate` and the interactive mode: plan, show, check, write.
+
+import fs from "node:fs";
+import path from "node:path";
+
+import { gitState, unifiedDiff, validate, writeAll } from "./apply.js";
+import { PROVIDERS } from "./edge/index.js";
+import { planMigration, uniformDependencies } from "./migrate.js";
+import { publishedAt } from "./registry.js";
+import { TARGET_VERSION } from "./report.js";
+import { scanProject } from "./scan.js";
+
+export const NAME = "uniform-next-app-router-upgrade";
+
+export function colors(enabled) {
+  return (code, s) => (enabled ? `\u001b[${code}m${s}\u001b[0m` : s);
+}
+
+/** Phase 1, and phase 2 when `edge` names a provider, as one plan. */
+export async function buildPlan(root, { edge, uniformData } = {}) {
+  const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+  const published = await publishedAt(uniformDependencies(pkg), TARGET_VERSION);
+  const phase1 = planMigration(root, { published });
+  let changes = phase1.changes.map((change) => ({ ...change, phase: 1 }));
+  let contents = phase1.contents;
+  let steps = [...phase1.manual];
+  let reminders = [];
+
+  if (edge) {
+    const phase2 = PROVIDERS[edge].plan(root, { base: phase1.contents });
+    changes = [...changes, ...phase2.changes.map((change) => ({ ...change, phase: 2 }))];
+    contents = new Map([...phase1.contents, ...phase2.contents]);
+    steps = [...steps, ...phase2.manual];
+    reminders = phase2.reminders ?? [];
+  }
+
+  const after = scanProject(root, { uniformDataDir: uniformData, contents });
+  return {
+    changes,
+    contents,
+    steps,
+    reminders,
+    manual: after.findings.filter((f) => f.severity === "error"),
+    reviews: after.findings.filter((f) => f.severity === "warning"),
+  };
+}
+
+/**
+ * Runs the migration and returns an exit code: 0 no code changes left, 1 manual changes left,
+ * 2 nothing was written.
+ * `ask(question, defaultYes)` returns a promise of true or false. Without it, the flow uses the
+ * options only.
+ */
+export async function executeMigration({ root, edge, dryRun, yes, allowDirty, color, uniformData, ask, interactive = false, diff = true }) {
+  const c = colors(color);
+  const plan = await buildPlan(root, { edge, uniformData });
+  const { changes, contents, steps, reminders, manual, reviews } = plan;
+
+  printChanges(root, changes, c);
+  if (changes.length && (diff === true || (diff === "ask" && ask && (await ask("Show the diff?", true))))) {
+    for (const [file, text] of contents) {
+      console.log(unifiedDiff(path.relative(root, file), fs.readFileSync(file, "utf8"), text, { color }));
+      console.log("");
+    }
+  }
+  printManual(manual, reviews, steps, c);
+  if (reminders.length) {
+    console.log(c("36;1", "Reminders:"));
+    for (const reminder of reminders) console.log(`  ${c("36", "•")} ${reminder}`);
+    console.log("");
+  }
+
+  const exitCode = manual.length || steps.length ? 1 : 0;
+  if (!changes.length || !contents.size) return exitCode;
+
+  const problems = validate(contents);
+  if (problems.length) {
+    console.error(c("31;1", "Nothing was written. A change makes a file that does not parse:"));
+    for (const problem of problems) console.error(`  ${path.relative(root, problem.file)}: ${problem.message}`);
+    console.error("Please report this problem to Uniform, with the file.");
+    return 2;
+  }
+
+  if (dryRun) {
+    console.log(c("1", "Dry run: no files were changed."));
+    return exitCode;
+  }
+
+  const git = gitState(root, [...contents.keys()]);
+  if (!allowDirty && (git.notGit || git.dirty.length)) {
+    if (git.notGit) {
+      console.error(c("31;1", "The app is not in a git repository, so you cannot undo the changes with git."));
+    } else {
+      console.error(c("31;1", "These files contain changes that are not committed:"));
+      for (const file of git.dirty) console.error(`  ${file}`);
+    }
+    // Only the interactive mode asks. With options, --allow-dirty is the only way past this check.
+    const proceed = interactive && ask ? await ask("Write the changes anyway?", false) : false;
+    if (!proceed) {
+      console.error(interactive ? "Nothing was written." : "Nothing was written. Commit or stash the changes first, or use --allow-dirty.");
+      return 2;
+    }
+  }
+
+  if (!yes) {
+    let approved = false;
+    if (ask) approved = await ask(`Write ${changes.length} change(s) to ${contents.size} file(s)?`, false);
+    else {
+      console.error("Nothing was written. To write the changes in a shell without a terminal, use --yes.");
+      return 2;
+    }
+    if (!approved) {
+      console.log("Nothing was written.");
+      return 2;
+    }
+  }
+
+  try {
+    writeAll(contents);
+  } catch (error) {
+    console.error(c("31;1", `Nothing was written: ${error.message}`));
+    return 2;
+  }
+
+  console.log(c("32;1", `Wrote ${changes.length} change(s) to ${contents.size} file(s).`));
+  console.log("");
+  console.log("Next steps:");
+  const next = [
+    "Install the new versions: npm install (or pnpm install, or yarn).",
+    ...(manual.length + steps.length ? [`Do the ${manual.length + steps.length} manual change(s) above.`] : []),
+    `Run the check again: ${NAME} check`,
+    edge ? "Build and start the app, and do the edge mode test of the docs: next build && next start" : "Build and test the app: next build",
+    "Read the changes: git diff",
+  ];
+  next.forEach((step, i) => console.log(`  ${i + 1}. ${step}`));
+  if (edge) console.log(c("2", `  Docs: ${PROVIDERS[edge].docs}`));
+  console.log("");
+  return exitCode;
+}
+
+function printChanges(root, changes, c) {
+  if (!changes.length) {
+    console.log("No automatic changes are necessary.");
+    console.log("");
+    return;
+  }
+  for (const phase of [1, 2]) {
+    const items = changes.filter((change) => change.phase === phase);
+    if (!items.length) continue;
+    const title = phase === 1 ? "Phase 1: upgrade the SDK" : "Phase 2: turn on edge mode";
+    console.log(c("1", `${title} (${items.length} automatic change(s)):`));
+    for (const change of items) console.log(`  ${c("32", "•")} ${change.file}${change.line ? `:${change.line}` : ""}  ${change.description}`);
+    console.log("");
+  }
+}
+
+function printManual(manual, reviews, steps, c) {
+  if (manual.length || steps.length) {
+    console.log(c("31;1", `Manual changes (${manual.length + steps.length}). The migration does not change this code, because the correct change depends on your app:`));
+    for (const step of steps) console.log(`  ${c("31", "•")} ${step}`);
+    for (const f of manual) {
+      console.log(`  ${c("31", "•")} ${f.file ? `${f.file}${f.line ? `:${f.line}` : ""}  ` : ""}${f.message}`);
+      console.log(`    Fix: ${f.fix}`);
+    }
+    console.log("");
+  } else {
+    console.log(c("32", "No manual code changes are necessary."));
+    console.log("");
+  }
+  if (reviews.length) {
+    console.log(c("33;1", `Behavior changes to review (${reviews.length}). For the details, run: ${NAME} check`));
+    for (const f of reviews) console.log(`  ${c("33", "•")} ${f.title}${f.file ? c("2", `  (${f.file}${f.line ? `:${f.line}` : ""})`) : ""}`);
+    console.log("");
+  }
+}
+
+/** A short status of the project, for the interactive mode. */
+export function projectStatus(root, { uniformData } = {}) {
+  const scan = scanProject(root, { uniformDataDir: uniformData });
+  const pkg = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const phase1 = planMigration(root);
+  const text = (file) => (fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "");
+  const middleware = ["middleware.ts", "middleware.js", "src/middleware.ts", "src/middleware.js", "proxy.ts", "src/proxy.ts"]
+    .map((file) => text(path.join(root, file)))
+    .join("\n");
+  return {
+    scan,
+    sdkVersion: deps["@uniformdev/next-app-router"],
+    atTarget: deps["@uniformdev/next-app-router"] === TARGET_VERSION,
+    phase1Pending: phase1.changes.length,
+    edgeMode: /vercelUniformEdgeMiddleware/.test(middleware) ? "vercel" : /uniformEdgeMiddleware|handleUniformEdgeRoute/.test(middleware) ? "custom" : undefined,
+  };
+}