vize 0.303.0 → 0.310.0

package/src/init/detect.ts

@@ -0,0 +1,221 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+  dependencyNames,
+  OXLINT_CONFIG_FILES,
+  parsePackageJson,
+  readRequiredFile,
+  VIZE_CONFIG_FILES,
+} from "../setup/config.js";
+
+export const NUXT_CONFIG_FILES = [
+  "nuxt.config.ts",
+  "nuxt.config.mts",
+  "nuxt.config.js",
+  "nuxt.config.mjs",
+] as const;
+
+export const VITE_CONFIG_FILES = [
+  "vite.config.ts",
+  "vite.config.mts",
+  "vite.config.js",
+  "vite.config.mjs",
+] as const;
+
+export type PackageManager = "pnpm" | "npm" | "yarn" | "bun";
+
+/**
+ * Bundler integration `init` can wire up.
+ *
+ * Nuxt outranks Vite because a Nuxt project owns its own Vite instance: adding
+ * `@vizejs/vite-plugin` to a Nuxt-managed Vite config would fight the module.
+ */
+export type Framework = "nuxt" | "vite" | "none";
+
+export interface ProjectDetection {
+  readonly root: string;
+  readonly packageManager: PackageManager | null;
+  readonly framework: Framework;
+  readonly nuxtConfig: string | null;
+  readonly viteConfigs: readonly string[];
+  readonly usesVitePlus: boolean;
+  readonly typescript: boolean;
+  readonly tsconfig: string | null;
+  readonly vizeConfig: string | null;
+  readonly oxlintConfig: string | null;
+  readonly hasVitePlusLintBlock: boolean;
+  readonly hasVizeVitePlugin: boolean;
+  readonly hasVizeNuxtModule: boolean;
+  readonly dependencies: ReadonlySet<string>;
+  readonly scripts: Readonly<Record<string, string>>;
+  readonly vscodeRecommendsVize: boolean;
+}
+
+/**
+ * Package-manager detection.
+ *
+ * Deliberately mirrors `detect_package_manager` in
+ * `crates/vize_canon/src/batch/error.rs`, including the lockfile priority order
+ * and the `packageManager` prefix fallback. The Rust side suggests an install
+ * command in its corsa-not-found message; if the two ever disagreed, a user
+ * would be told to run `pnpm add` by one half of the toolchain and `npm install`
+ * by the other.
+ */
+export function detectPackageManager(root: string): PackageManager | null {
+  const exists = (name: string): boolean => fs.existsSync(path.join(root, name));
+  if (exists("pnpm-lock.yaml")) {
+    return "pnpm";
+  }
+  if (exists("bun.lockb") || exists("bun.lock")) {
+    return "bun";
+  }
+  if (exists("yarn.lock")) {
+    return "yarn";
+  }
+  if (exists("package-lock.json")) {
+    return "npm";
+  }
+  return detectPackageManagerField(root);
+}
+
+function detectPackageManagerField(root: string): PackageManager | null {
+  let source: string;
+  try {
+    source = fs.readFileSync(path.join(root, "package.json"), "utf8");
+  } catch {
+    return null;
+  }
+  let field: unknown;
+  try {
+    field = (JSON.parse(source) as { packageManager?: unknown }).packageManager;
+  } catch {
+    return null;
+  }
+  if (typeof field !== "string") {
+    return null;
+  }
+  for (const candidate of ["pnpm", "yarn", "bun", "npm"] as const) {
+    if (field.startsWith(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+
+/**
+ * Applies an explicit `--vite` / `--nuxt` choice over what detection concluded.
+ *
+ * Overriding the framework rather than branching later keeps one code path: the
+ * planner, the prompt and the printed detection summary all see the same answer,
+ * so the summary cannot claim Vite while the plan configures Nuxt.
+ */
+export function withFramework(
+  detection: ProjectDetection,
+  framework: Framework | null,
+): ProjectDetection {
+  return framework === null || framework === detection.framework
+    ? detection
+    : { ...detection, framework };
+}
+
+export function detectProject(root: string): ProjectDetection {
+  const packagePath = path.join(root, "package.json");
+  const packageSource = readRequiredFile(packagePath, "No package.json found");
+  const packageJson = parsePackageJson(packagePath, packageSource);
+  const dependencies = dependencyNames(packageJson);
+  const scripts = readScripts(packageJson);
+
+  const nuxtConfig = findExisting(root, NUXT_CONFIG_FILES);
+  const viteConfigs = VITE_CONFIG_FILES.filter((candidate) =>
+    fs.existsSync(path.join(root, candidate)),
+  );
+  const viteSource = viteConfigs.length === 1 ? readFile(root, viteConfigs[0]!) : null;
+  const nuxtSource = nuxtConfig === null ? null : readFile(root, nuxtConfig);
+
+  return {
+    root,
+    packageManager: detectPackageManager(root),
+    framework: detectFramework(nuxtConfig, viteConfigs, dependencies),
+    nuxtConfig,
+    viteConfigs,
+    usesVitePlus: detectVitePlus(dependencies, viteSource, scripts),
+    typescript: dependencies.has("typescript") || fs.existsSync(path.join(root, "tsconfig.json")),
+    tsconfig: fs.existsSync(path.join(root, "tsconfig.json")) ? "tsconfig.json" : null,
+    vizeConfig: findExisting(root, VIZE_CONFIG_FILES),
+    oxlintConfig: findExisting(root, OXLINT_CONFIG_FILES),
+    hasVitePlusLintBlock: viteSource !== null && viteSource.includes("oxlint-plugin-vize"),
+    hasVizeVitePlugin: viteSource !== null && viteSource.includes("@vizejs/vite-plugin"),
+    hasVizeNuxtModule: nuxtSource !== null && nuxtSource.includes("@vizejs/nuxt"),
+    dependencies,
+    scripts,
+    vscodeRecommendsVize: detectVscodeRecommendation(root),
+  };
+}
+
+function detectFramework(
+  nuxtConfig: string | null,
+  viteConfigs: readonly string[],
+  dependencies: ReadonlySet<string>,
+): Framework {
+  if (nuxtConfig !== null || dependencies.has("nuxt")) {
+    return "nuxt";
+  }
+  return viteConfigs.length > 0 ? "vite" : "none";
+}
+
+/**
+ * Whether the project's lint command is `vp lint` rather than the `oxlint` binary.
+ *
+ * This single boolean decides which file `init` must write the Oxlint
+ * configuration into, so it is deliberately generous: a project is treated as a
+ * Vite+ project if the dependency is declared, if its Vite config imports from
+ * `vite-plus`, or if any script invokes `vp`. Guessing "plain Oxlint" for a
+ * Vite+ project is the failure that #3389 documented — `vp lint` would ignore
+ * `.oxlintrc.json` and report zero Vize diagnostics while exiting 0.
+ */
+function detectVitePlus(
+  dependencies: ReadonlySet<string>,
+  viteSource: string | null,
+  scripts: Readonly<Record<string, string>>,
+): boolean {
+  if (dependencies.has("vite-plus")) {
+    return true;
+  }
+  if (viteSource !== null && /from\s+["']vite-plus["']/u.test(viteSource)) {
+    return true;
+  }
+  return Object.values(scripts).some((command) => /(?:^|[\s&|;])vpx?(?:\s|$)/u.test(command));
+}
+
+function detectVscodeRecommendation(root: string): boolean {
+  let source: string;
+  try {
+    source = fs.readFileSync(path.join(root, ".vscode", "extensions.json"), "utf8");
+  } catch {
+    return false;
+  }
+  return source.includes("ubugeeei.vize");
+}
+
+function readScripts(packageJson: Record<string, unknown>): Record<string, string> {
+  const scripts = packageJson.scripts;
+  if (typeof scripts !== "object" || scripts === null || Array.isArray(scripts)) {
+    return {};
+  }
+  const entries: Record<string, string> = {};
+  for (const [name, command] of Object.entries(scripts)) {
+    if (typeof command === "string") {
+      entries[name] = command;
+    }
+  }
+  return entries;
+}
+
+function findExisting(root: string, candidates: readonly string[]): string | null {
+  return candidates.find((candidate) => fs.existsSync(path.join(root, candidate))) ?? null;
+}
+
+function readFile(root: string, relative: string): string {
+  return fs.readFileSync(path.join(root, relative), "utf8");
+}

package/src/init/edit-config.ts

@@ -0,0 +1,161 @@
+import { VITE_LINT_BLOCK, VITE_LINT_IMPORT, VITE_PLUGIN_IMPORT } from "./templates.js";
+import { countConfigCalls, findTopLevelKey, readTopLevelArray } from "./top-level.js";
+
+/**
+ * Conservative source edits for user-owned `vite.config.*` and `nuxt.config.*`.
+ *
+ * Every function here returns `null` rather than guessing. A wrong edit to a
+ * build config breaks the project; a `null` costs the user one paste of a
+ * snippet `init` prints for them.
+ */
+
+const VITE_CALLEE = "defineConfig";
+const NUXT_CALLEE = "defineNuxtConfig";
+
+/**
+ * `defineConfig({` plus the newline that usually follows it.
+ *
+ * The trailing newline is consumed and re-emitted by the injectors so an
+ * inserted key does not leave a stray blank line behind in the user's file.
+ */
+const VITE_OPENING = /\bdefineConfig\s*\(\s*\{[^\S\r\n]*(?:\r?\n)?/u;
+const NUXT_OPENING = /\bdefineNuxtConfig\s*\(\s*\{[^\S\r\n]*(?:\r?\n)?/u;
+
+/**
+ * Whether a Vite config is a single plain `defineConfig({ ... })` call that a
+ * new top-level key can be inserted into.
+ *
+ * Anything else -- several `defineConfig` calls, a config built from a variable,
+ * or a config that already declares the key -- is left alone.
+ */
+export function canInjectViteKey(source: string, key: string): boolean {
+  if (hasTopLevelKey(source, key)) {
+    return false;
+  }
+  return countConfigCalls(source, VITE_CALLEE) === 1;
+}
+
+/** Whether the Vite config declares `key` at the top level of its `defineConfig` call. */
+export function hasTopLevelKey(source: string, key: string): boolean {
+  return findTopLevelKey(source, VITE_CALLEE, key) !== null;
+}
+
+/** Whether the Vite+ `lint` block can be injected into this source. */
+export function canInjectViteLint(source: string): boolean {
+  if (source.includes("oxlint-plugin-vize")) {
+    return false;
+  }
+  return canInjectViteKey(source, "lint");
+}
+
+/**
+ * Inserts the `lint` block, and its import, into a Vite config.
+ *
+ * Returns `null` when the source does not have the shape `canInjectViteLint`
+ * accepts, so callers cannot inject blindly.
+ */
+export function injectViteLint(source: string): string | null {
+  if (!canInjectViteLint(source)) {
+    return null;
+  }
+  const withImport = insertImport(source, VITE_LINT_IMPORT);
+  if (withImport === null) {
+    return null;
+  }
+  return withImport.replace(VITE_OPENING, () => `defineConfig({\n${VITE_LINT_BLOCK}`);
+}
+
+/**
+ * Adds `vize()` to a Vite config's top-level `plugins` array, importing the
+ * plugin.
+ *
+ * The array is located by depth-aware scan rather than by regex: a Vite+ config
+ * can carry a second `plugins` key inside its `lint` block, and appending Vize's
+ * Vite plugin to Oxlint's plugin list would corrupt both.
+ */
+export function injectVitePlugin(source: string): string | null {
+  if (source.includes("@vizejs/vite-plugin")) {
+    return null;
+  }
+  const withImport = insertImport(source, VITE_PLUGIN_IMPORT);
+  if (withImport === null) {
+    return null;
+  }
+  const plugins = readTopLevelArray(withImport, VITE_CALLEE, "plugins");
+  if (plugins !== null) {
+    return insertArrayEntry(withImport, plugins.contentStart, "vize()", plugins.empty);
+  }
+  if (findTopLevelKey(withImport, VITE_CALLEE, "plugins") !== null) {
+    // `plugins` exists but is not an array literal; inserting would change what
+    // the config evaluates to.
+    return null;
+  }
+  if (!canInjectViteKey(withImport, "plugins")) {
+    return null;
+  }
+  return withImport.replace(VITE_OPENING, () => `defineConfig({\n  plugins: [vize()],\n`);
+}
+
+/**
+ * Adds `"@vizejs/nuxt"` to a Nuxt config's top-level `modules` array.
+ *
+ * Nuxt owns its own Vite instance, so the module is the supported integration
+ * point; adding `@vizejs/vite-plugin` to a Nuxt-managed Vite config would fight
+ * it.
+ */
+export function injectNuxtModule(source: string): string | null {
+  if (source.includes("@vizejs/nuxt")) {
+    return null;
+  }
+  if (countConfigCalls(source, NUXT_CALLEE) !== 1) {
+    return null;
+  }
+  const modules = readTopLevelArray(source, NUXT_CALLEE, "modules");
+  if (modules !== null) {
+    return insertArrayEntry(source, modules.contentStart, '"@vizejs/nuxt"', modules.empty);
+  }
+  if (findTopLevelKey(source, NUXT_CALLEE, "modules") !== null) {
+    return null;
+  }
+  return source.replace(NUXT_OPENING, () => `defineNuxtConfig({\n  modules: ["@vizejs/nuxt"],\n`);
+}
+
+/**
+ * Inserts `entry` as the first element of an array literal.
+ *
+ * Prepending keeps the user's existing entries in their original order and
+ * leaves their formatting alone.
+ */
+function insertArrayEntry(
+  source: string,
+  contentStart: number,
+  entry: string,
+  empty: boolean,
+): string {
+  const suffix = empty ? "" : ", ";
+  const tail = empty ? source.slice(contentStart).replace(/^\s*/u, "") : source.slice(contentStart);
+  return `${source.slice(0, contentStart)}${entry}${suffix}${tail}`;
+}
+
+/**
+ * Inserts an import after the last existing top-level import.
+ *
+ * A config with no imports at all returns `null`: the safe insertion point is
+ * not obvious, and the file is unusual enough to be worth a human look.
+ */
+function insertImport(source: string, importLine: string): string | null {
+  if (source.includes(importLine.trimEnd())) {
+    return source;
+  }
+  const imports = [
+    ...source.matchAll(
+      /^import[^\r\n]*(?:from\s+["'][^"']+["']|["'][^"']+["'])\s*;?[^\S\r\n]*(?:\r?\n|$)/gmu,
+    ),
+  ];
+  const lastImport = imports.at(-1);
+  if (lastImport === undefined || lastImport.index === undefined) {
+    return null;
+  }
+  const end = lastImport.index + lastImport[0].length;
+  return source.slice(0, end) + importLine + source.slice(end);
+}

package/src/init/lint-target.ts

@@ -0,0 +1,202 @@
+import type { ProjectDetection } from "./detect.js";
+import { canInjectViteLint, hasTopLevelKey } from "./edit-config.js";
+import { VITE_LINT_MERGE_SNIPPET, VITE_LINT_SNIPPET } from "./templates.js";
+
+/**
+ * Oxlint config filenames the `oxlint` binary actually auto-discovers.
+ *
+ * Verified against oxlint 1.64: `.oxlintrc.json`, `.oxlintrc.jsonc` and
+ * `oxlint.config.ts` are read; `oxlint.config.mts`, `.js`, `.mjs`, `.cjs` and
+ * `.cts` produce a run byte-identical to having no config at all. The wider list
+ * in `setup/config.ts` treats all eight as configuration, which is #3474. `init`
+ * uses this narrower list so it never reports an unread file as configured.
+ */
+export const DISCOVERED_OXLINT_CONFIG_FILES = [
+  ".oxlintrc.json",
+  ".oxlintrc.jsonc",
+  "oxlint.config.ts",
+] as const;
+
+/** Filename `init` writes when the `oxlint` binary is the lint entry point. */
+export const INIT_OXLINT_CONFIG_FILE = "oxlint.config.ts";
+
+/**
+ * Where a project's Oxlint configuration has to live to be read.
+ *
+ * `vp lint` and `vp check` read the `lint` block of `vite.config.ts` and never
+ * read `.oxlintrc.json`; the `oxlint` and `oxlint-vize` binaries read
+ * `.oxlintrc.json` and never read `vite.config.ts`. Writing the wrong one leaves
+ * a project that looks configured, reports zero `vize/*` diagnostics and exits
+ * `0` -- the defect #3389 recorded and #3407 fixed. Every branch below therefore
+ * follows the command the project will actually run, not the file that is
+ * easiest to write.
+ */
+export type LintTargetKind =
+  /** Vite+ project: the `lint` block in the Vite config is the only readable place. */
+  | "vite-plus"
+  /** No Vite+: the `oxlint` binary reads its own config file. */
+  | "oxlint"
+  /** Both entry points are in use; both files get written from one settings object. */
+  | "both"
+  /** Vite+ project whose Vite config cannot be edited safely. Nothing is written. */
+  | "manual";
+
+export interface LintTarget {
+  readonly kind: LintTargetKind;
+  /** Vite config to receive the `lint` block, when one can be edited. */
+  readonly viteConfig: string | null;
+  /** Oxlint config file to write, when the `oxlint` binary is an entry point. */
+  readonly oxlintConfig: string | null;
+  /** Existing Oxlint config left untouched, if any. */
+  readonly preservedOxlintConfig: string | null;
+  /** Why this target was chosen. Always shown to the user. */
+  readonly reason: string;
+  /**
+   * Set when the project needs a Vite+ `lint` block that `init` will not write.
+   * The caller must print the snippet and must not claim lint is configured.
+   */
+  readonly blockedReason: string | null;
+  /** Snippet to paste when `blockedReason` is set. */
+  readonly blockedSnippet: string | null;
+}
+
+export interface LintTargetInput {
+  readonly detection: ProjectDetection;
+  /** Source of the single Vite config, or `null` when there is not exactly one. */
+  readonly viteSource: string | null;
+}
+
+/**
+ * Chooses which Oxlint configuration file(s) the project needs.
+ *
+ * The `oxlint` binary is treated as an entry point whenever the project already
+ * carries a discovered Oxlint config or runs `oxlint` from a script. A Vite+
+ * project that also does either gets both files, generated from the same preset
+ * and help level, because keeping one of them silently stale is the same class
+ * of bug as writing the wrong one.
+ */
+export function resolveLintTarget(input: LintTargetInput): LintTarget {
+  const { detection } = input;
+  const existing = discoveredOxlintConfig(detection);
+  const runsOxlintBinary = existing !== null || hasOxlintScript(detection);
+
+  if (!detection.usesVitePlus) {
+    return {
+      kind: "oxlint",
+      viteConfig: null,
+      oxlintConfig: existing === null ? INIT_OXLINT_CONFIG_FILE : null,
+      preservedOxlintConfig: existing,
+      reason:
+        "no Vite+ detected, so `oxlint` is the lint entry point and reads " +
+        `${existing ?? INIT_OXLINT_CONFIG_FILE}`,
+      blockedReason: null,
+      blockedSnippet: null,
+    };
+  }
+
+  const viteConfig = detection.viteConfigs.length === 1 ? detection.viteConfigs[0]! : null;
+  const injectable = input.viteSource !== null && canInjectViteLint(input.viteSource);
+  if (!detection.hasVitePlusLintBlock && !injectable) {
+    const blocked = describeBlocked(detection, input.viteSource);
+    return {
+      kind: "manual",
+      viteConfig: null,
+      oxlintConfig: null,
+      preservedOxlintConfig: existing,
+      reason: "Vite+ detected, so `vp lint` reads the `lint` block in the Vite config",
+      blockedReason: blocked.reason,
+      blockedSnippet: blocked.snippet,
+    };
+  }
+
+  if (!runsOxlintBinary) {
+    return {
+      kind: "vite-plus",
+      viteConfig,
+      oxlintConfig: null,
+      preservedOxlintConfig: null,
+      reason:
+        "Vite+ detected, so `vp lint` reads the `lint` block in " +
+        `${viteConfig ?? "the Vite config"} and never reads .oxlintrc.json`,
+      blockedReason: null,
+      blockedSnippet: null,
+    };
+  }
+
+  return {
+    kind: "both",
+    viteConfig,
+    oxlintConfig: existing === null ? INIT_OXLINT_CONFIG_FILE : null,
+    preservedOxlintConfig: existing,
+    reason:
+      "Vite+ and the `oxlint` binary are both in use, so the `lint` block in " +
+      `${viteConfig ?? "the Vite config"} and ${existing ?? INIT_OXLINT_CONFIG_FILE} ` +
+      "are written from the same preset",
+    blockedReason: null,
+    blockedSnippet: null,
+  };
+}
+
+/**
+ * The existing Oxlint config, restricted to names Oxlint actually reads.
+ *
+ * A project holding only `oxlint.config.mjs` is deliberately treated as having
+ * no Oxlint config, because that is how Oxlint treats it.
+ */
+export function discoveredOxlintConfig(detection: ProjectDetection): string | null {
+  const existing = detection.oxlintConfig;
+  if (existing === null) {
+    return null;
+  }
+  return (DISCOVERED_OXLINT_CONFIG_FILES as readonly string[]).includes(existing) ? existing : null;
+}
+
+/** An Oxlint config file that is present but which Oxlint will never read. */
+export function unreadOxlintConfig(detection: ProjectDetection): string | null {
+  const existing = detection.oxlintConfig;
+  if (existing === null || discoveredOxlintConfig(detection) !== null) {
+    return null;
+  }
+  return existing;
+}
+
+function hasOxlintScript(detection: ProjectDetection): boolean {
+  return Object.values(detection.scripts).some((command) =>
+    /(?:^|[\s&|;])oxlint(?:-vize)?(?:\s|$)/u.test(command),
+  );
+}
+
+/**
+ * Why the `lint` block will not be written.
+ *
+ * The message is the whole value of a blocked result, so it names the specific
+ * obstacle instead of a generic "could not edit". An existing `lint` block in
+ * particular is a merge the user has to make, not a failure of the file.
+ */
+function describeBlocked(
+  detection: ProjectDetection,
+  viteSource: string | null,
+): { readonly reason: string; readonly snippet: string } {
+  if (detection.viteConfigs.length === 0) {
+    return { reason: "no vite.config file to hold the `lint` block", snippet: VITE_LINT_SNIPPET };
+  }
+  if (detection.viteConfigs.length > 1) {
+    return {
+      reason: `several Vite configs (${detection.viteConfigs.join(", ")}), so the target is ambiguous`,
+      snippet: VITE_LINT_SNIPPET,
+    };
+  }
+  const filename = detection.viteConfigs[0]!;
+  if (viteSource !== null && hasTopLevelKey(viteSource, "lint")) {
+    return {
+      reason:
+        `${filename} already has a \`lint\` block and merging into it would risk dropping ` +
+        "settings, so spread createVizeLintConfig() into it by hand",
+      snippet: VITE_LINT_MERGE_SNIPPET,
+    };
+  }
+  return {
+    reason: `${filename} is not a single plain defineConfig({ ... }) call`,
+    snippet: VITE_LINT_SNIPPET,
+  };
+}

package/src/init/plan-bundler.ts

@@ -0,0 +1,97 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import type { ProjectDetection } from "./detect.js";
+import { injectNuxtModule, injectVitePlugin } from "./edit-config.js";
+import { skipped, type PlanDraft } from "./plan-types.js";
+
+/**
+ * Plans the bundler integration: the Vite plugin, or the Nuxt module.
+ *
+ * Nuxt outranks Vite because a Nuxt project owns its own Vite instance --
+ * adding `@vizejs/vite-plugin` to a Nuxt-managed Vite config would fight the
+ * module rather than complement it.
+ *
+ * @returns the possibly-edited Vite config source, or the input unchanged.
+ */
+export function planBundler(
+  detection: ProjectDetection,
+  viteDraft: string | null,
+  draft: PlanDraft,
+): string | null {
+  if (detection.framework === "nuxt") {
+    planNuxtModule(detection, draft);
+    return viteDraft;
+  }
+  if (detection.framework !== "vite" || detection.viteConfigs.length !== 1) {
+    draft.features.push(skipped("bundler", "no single vite.config or nuxt.config to configure"));
+    return viteDraft;
+  }
+  draft.dependencies.add("@vizejs/vite-plugin");
+  const filename = detection.viteConfigs[0]!;
+  if (detection.hasVizeVitePlugin) {
+    draft.features.push({
+      id: "bundler",
+      outcome: "unchanged",
+      detail: `${filename} already uses @vizejs/vite-plugin`,
+      snippet: null,
+    });
+    return viteDraft;
+  }
+  const injected = viteDraft === null ? null : injectVitePlugin(viteDraft);
+  if (injected === null) {
+    draft.features.push({
+      id: "bundler",
+      outcome: "blocked",
+      detail: `${filename} has no plugins array this tool can extend safely`,
+      snippet: "plugins: [vize()]",
+    });
+    return viteDraft;
+  }
+  draft.features.push({
+    id: "bundler",
+    outcome: "configured",
+    detail: `adds vize() to ${filename}`,
+    snippet: null,
+  });
+  return injected;
+}
+
+function planNuxtModule(detection: ProjectDetection, draft: PlanDraft): void {
+  draft.dependencies.add("@vizejs/nuxt");
+  if (detection.nuxtConfig === null) {
+    draft.features.push(skipped("bundler", "no nuxt.config file to add @vizejs/nuxt to"));
+    return;
+  }
+  if (detection.hasVizeNuxtModule) {
+    draft.features.push({
+      id: "bundler",
+      outcome: "unchanged",
+      detail: `${detection.nuxtConfig} already lists @vizejs/nuxt`,
+      snippet: null,
+    });
+    return;
+  }
+  const source = fs.readFileSync(path.join(detection.root, detection.nuxtConfig), "utf8");
+  const injected = injectNuxtModule(source);
+  if (injected === null) {
+    draft.features.push({
+      id: "bundler",
+      outcome: "blocked",
+      detail: `${detection.nuxtConfig} is not a single plain defineNuxtConfig({ ... }) call`,
+      snippet: 'modules: ["@vizejs/nuxt"]',
+    });
+    return;
+  }
+  draft.files.push({
+    filename: path.join(detection.root, detection.nuxtConfig),
+    source: injected,
+  });
+  draft.updatedFiles.push(detection.nuxtConfig);
+  draft.features.push({
+    id: "bundler",
+    outcome: "configured",
+    detail: `adds @vizejs/nuxt to ${detection.nuxtConfig}`,
+    snippet: null,
+  });
+}