vize 0.303.0 → 0.310.0

package/dist/cli.mjs

@@ -2,6 +2,7 @@ import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
+import readline from "node:readline";
 //#region src/setup/config.ts
 const VIZE_CONFIG_FILES = [
 	"vize.config.pkl",
@@ -152,6 +153,1587 @@ function isNodeError(value) {
 	return value instanceof Error;
 }
 //#endregion
+//#region src/init/templates.ts
+/**
+* Config sources `vize init` writes.
+*
+* Every Oxlint-facing template here is derived from one settings object so the
+* `vp lint` block and the `oxlint` config can never describe different presets.
+* See `lint-target.ts` for why writing the wrong one of the two is silent.
+*/
+/** Preset both Oxlint entry points run with. The bridge's own default. */
+const INIT_LINT_PRESET = "general-recommended";
+/** `settings.vize.helpLevel` both Oxlint entry points run with. */
+const INIT_LINT_HELP_LEVEL = "short";
+/** VS Code extension id published from `editors/vscode`. */
+const VSCODE_EXTENSION_ID = "ubugeeei.vize";
+/**
+* Builds `vize.config.ts` from the selected features.
+*
+* Only selected features contribute a block, so a project that asked for the
+* formatter alone does not silently get a type checker it never opted into.
+*/
+function renderVizeConfig(features) {
+	const blocks = [`  compiler: {
+    templateSyntax: "standard",
+  },`];
+	if (features.lint) blocks.push(`  linter: {
+    enabled: true,
+    preset: "${INIT_LINT_PRESET}",
+  },`);
+	if (features.fmt) blocks.push(`  formatter: {
+    singleAttributePerLine: false,
+    sortBlocks: true,
+  },`);
+	if (features.typecheck) blocks.push(`  typeChecker: {
+    enabled: true,
+    strict: true,
+  },`);
+	if (features.vite) blocks.push(`  vite: {
+    scanPatterns: ["src/**/*.vue"],
+  },`);
+	return `import { defineConfig } from "vize";
+
+export default defineConfig({
+${blocks.join("\n")}
+});
+`;
+}
+/**
+* Config for the `oxlint` binary.
+*
+* `.oxlintrc.json` cannot import `configs.recommended`, and the bridge only runs
+* `vize/*` rules that appear in `rules`, so a JSON config would need every rule
+* id inlined and would rot on the next rule addition. `oxlint.config.ts` is
+* Oxlint's TypeScript config format and is auto-discovered (verified against
+* oxlint 1.64; `oxlint.config.mjs`, `.js`, `.cjs`, `.mts` and `.cts` are not --
+* see #3474), so it is the only form that stays correct over time.
+*/
+const INIT_OXLINT_CONFIG = `import { defineConfig } from "oxlint";
+import { configs } from "oxlint-plugin-vize";
+
+export default defineConfig({
+  plugins: ["vue"],
+  jsPlugins: ["oxlint-plugin-vize"],
+  settings: {
+    vize: {
+      preset: "${INIT_LINT_PRESET}",
+      helpLevel: "${INIT_LINT_HELP_LEVEL}",
+    },
+  },
+  rules: configs.recommended,
+});
+`;
+/** Import line the Vite+ `lint` block needs. */
+const VITE_LINT_IMPORT = "import { createVizeLintConfig } from \"oxlint-plugin-vize\";\n";
+/**
+* The Vite+ `lint` block, the only Oxlint configuration `vp lint` and `vp check`
+* read.
+*
+* `createVizeLintConfig()` returns the whole block rather than fragments, which
+* is what makes the `jsPlugins` entry impossible to omit. Hand-assembling the
+* block is how a config ends up looking wired while reporting nothing.
+*/
+const VITE_LINT_BLOCK = `  lint: createVizeLintConfig({
+    preset: "${INIT_LINT_PRESET}",
+    settings: {
+      helpLevel: "${INIT_LINT_HELP_LEVEL}",
+    },
+  }),
+`;
+/** Snippet printed when a Vite config has no `lint` block and cannot be edited safely. */
+const VITE_LINT_SNIPPET = `import { createVizeLintConfig } from "oxlint-plugin-vize";
+
+export default defineConfig({
+${VITE_LINT_BLOCK}});
+`;
+/**
+* Snippet printed when the Vite config already has a `lint` block.
+*
+* Spreading is the documented way to keep an existing block's other keys while
+* still taking the whole Vize block, `jsPlugins` included.
+*/
+const VITE_LINT_MERGE_SNIPPET = `import { createVizeLintConfig } from "oxlint-plugin-vize";
+
+export default defineConfig({
+  lint: {
+    ...createVizeLintConfig({
+      preset: "${INIT_LINT_PRESET}",
+      settings: {
+        helpLevel: "${INIT_LINT_HELP_LEVEL}",
+      },
+    }),
+    // keep your existing lint keys here
+  },
+});
+`;
+const VITE_PLUGIN_IMPORT = "import vize from \"@vizejs/vite-plugin\";\n";
+/**
+* `.vscode/extensions.json` written when no file exists yet.
+*
+* Recommendations are chosen over `code --install-extension` because they are
+* checked in, apply to the whole team, and change nothing on the machine that
+* runs `init`.
+*/
+function renderVscodeExtensions(indent) {
+	return `${JSON.stringify({ recommendations: [VSCODE_EXTENSION_ID] }, null, indent)}\n`;
+}
+/** Editor integrations shipped from this repo, reported alongside the VS Code one. */
+const EDITOR_INTEGRATIONS = [
+	"VS Code: ubugeeei.vize (recommended in .vscode/extensions.json)",
+	"Zed: tools/zed-vize",
+	"Neovim: tools/nvim-vize",
+	"Vim: tools/vim-vize",
+	"Helix: tools/helix-vize",
+	"Emacs: tools/emacs-vize"
+];
+//#endregion
+//#region src/init/top-level.ts
+/**
+* Depth-aware lookup of a top-level key in a `defineConfig({ ... })` call.
+*
+* A plain regex cannot tell the config's own `plugins` key from the `plugins`
+* key inside a `lint: { ... }` block, and picking the wrong one rewrites a part
+* of the user's config they never asked to change. This scanner tracks bracket
+* depth and skips strings, template literals and comments, so a key only matches
+* at depth 0 of the config object.
+*
+* It is not a JavaScript parser and does not try to be: template-literal
+* substitutions and regex literals are treated as ordinary text. Both make the
+* scan give up or miss, which turns into a refusal to edit -- the safe direction.
+*/
+const IDENTIFIER = /^[$A-Z_a-z][$\w]*/u;
+const KEY_SEPARATOR = /^\s*:/u;
+/** Finds `key` at the top level of `callee({ ... })`, or `null`. */
+function findTopLevelKey(source, callee, key) {
+	const opening = new RegExp(`\\b${callee}\\s*\\(\\s*\\{`, "u").exec(source);
+	if (opening === null) return null;
+	let index = opening.index + opening[0].length;
+	let depth = 0;
+	while (index < source.length) {
+		const char = source[index];
+		const skipped = skipNonCode(source, index);
+		if (skipped !== index) {
+			index = skipped;
+			continue;
+		}
+		if (char === "{" || char === "[" || char === "(") {
+			depth += 1;
+			index += 1;
+			continue;
+		}
+		if (char === "}" || char === "]" || char === ")") {
+			if (depth === 0) return null;
+			depth -= 1;
+			index += 1;
+			continue;
+		}
+		const identifier = IDENTIFIER.exec(source.slice(index));
+		if (identifier === null) {
+			index += 1;
+			continue;
+		}
+		const separator = KEY_SEPARATOR.exec(source.slice(index + identifier[0].length));
+		if (depth === 0 && identifier[0] === key && separator !== null) return {
+			keyStart: index,
+			valueStart: index + identifier[0].length + separator[0].length
+		};
+		index += identifier[0].length;
+	}
+	return null;
+}
+/** Number of `callee({` openings in the source. */
+function countConfigCalls(source, callee) {
+	return [...source.matchAll(new RegExp(`\\b${callee}\\s*\\(\\s*\\{`, "gu"))].length;
+}
+/**
+* Reads the array literal a top-level key is assigned to.
+*
+* Returns `null` when the value is not an array literal -- a spread from a
+* variable, or a helper call -- because inserting into those would change what
+* the config evaluates to.
+*/
+function readTopLevelArray(source, callee, key) {
+	const found = findTopLevelKey(source, callee, key);
+	if (found === null) return null;
+	const rest = source.slice(found.valueStart);
+	const leading = /^\s*/u.exec(rest)[0];
+	if (rest[leading.length] !== "[") return null;
+	const contentStart = found.valueStart + leading.length + 1;
+	return {
+		contentStart,
+		empty: /^\s*\]/u.test(source.slice(contentStart))
+	};
+}
+/**
+* Advances past a string, template literal or comment starting at `index`.
+*
+* Returns `index` unchanged when nothing at that position needs skipping.
+*/
+function skipNonCode(source, index) {
+	const char = source[index];
+	if (char === "\"" || char === "'" || char === "`") return skipQuoted(source, index, char);
+	if (char !== "/") return index;
+	const next = source[index + 1];
+	if (next === "/") {
+		const end = source.indexOf("\n", index);
+		return end === -1 ? source.length : end;
+	}
+	if (next === "*") {
+		const end = source.indexOf("*/", index + 2);
+		return end === -1 ? source.length : end + 2;
+	}
+	return index;
+}
+function skipQuoted(source, index, quote) {
+	let cursor = index + 1;
+	while (cursor < source.length) {
+		const char = source[cursor];
+		if (char === "\\") {
+			cursor += 2;
+			continue;
+		}
+		if (char === quote) return cursor + 1;
+		cursor += 1;
+	}
+	return source.length;
+}
+//#endregion
+//#region src/init/edit-config.ts
+/**
+* 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.
+*/
+function canInjectViteKey(source, key) {
+	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. */
+function hasTopLevelKey(source, key) {
+	return findTopLevelKey(source, VITE_CALLEE, key) !== null;
+}
+/** Whether the Vite+ `lint` block can be injected into this source. */
+function canInjectViteLint(source) {
+	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.
+*/
+function injectViteLint(source) {
+	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.
+*/
+function injectVitePlugin(source) {
+	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) 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.
+*/
+function injectNuxtModule(source) {
+	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, contentStart, entry, empty) {
+	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, importLine) {
+	if (source.includes(importLine.trimEnd())) return source;
+	const lastImport = [...source.matchAll(/^import[^\r\n]*(?:from\s+["'][^"']+["']|["'][^"']+["'])\s*;?[^\S\r\n]*(?:\r?\n|$)/gmu)].at(-1);
+	if (lastImport === void 0 || lastImport.index === void 0) return null;
+	const end = lastImport.index + lastImport[0].length;
+	return source.slice(0, end) + importLine + source.slice(end);
+}
+//#endregion
+//#region src/init/lint-target.ts
+/**
+* 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.
+*/
+const DISCOVERED_OXLINT_CONFIG_FILES = [
+	".oxlintrc.json",
+	".oxlintrc.jsonc",
+	"oxlint.config.ts"
+];
+/** Filename `init` writes when the `oxlint` binary is the lint entry point. */
+const INIT_OXLINT_CONFIG_FILE = "oxlint.config.ts";
+/**
+* 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.
+*/
+function resolveLintTarget(input) {
+	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 ?? "oxlint.config.ts"}`,
+		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 ?? "oxlint.config.ts"} 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.
+*/
+function discoveredOxlintConfig(detection) {
+	const existing = detection.oxlintConfig;
+	if (existing === null) return null;
+	return DISCOVERED_OXLINT_CONFIG_FILES.includes(existing) ? existing : null;
+}
+/** An Oxlint config file that is present but which Oxlint will never read. */
+function unreadOxlintConfig(detection) {
+	const existing = detection.oxlintConfig;
+	if (existing === null || discoveredOxlintConfig(detection) !== null) return null;
+	return existing;
+}
+function hasOxlintScript(detection) {
+	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, viteSource) {
+	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
+	};
+}
+//#endregion
+//#region src/init/select.ts
+const FEATURE_IDS = [
+	"lint",
+	"bundler",
+	"fmt",
+	"typecheck",
+	"editor"
+];
+/**
+* Turns detection into the five offers `init` presents.
+*
+* Already-configured features stay selected by default so a re-run is a no-op
+* the user can confirm rather than a set of boxes they have to re-tick.
+*/
+function offerFeatures(detection) {
+	return [
+		lintOffer(detection),
+		bundlerOffer(detection),
+		fmtOffer(detection),
+		typecheckOffer(detection),
+		editorOffer(detection)
+	];
+}
+/** Selection implied by detection alone, used by `--yes` and as the prompt default. */
+function defaultSelection(offers) {
+	const selection = {
+		lint: false,
+		bundler: false,
+		fmt: false,
+		typecheck: false,
+		editor: false
+	};
+	for (const offer of offers) selection[offer.id] = offer.defaultSelected;
+	return selection;
+}
+function lintOffer(detection) {
+	const configured = detection.usesVitePlus ? detection.hasVitePlusLintBlock : discoveredOxlintConfig(detection) !== null;
+	const unread = unreadOxlintConfig(detection);
+	return {
+		id: "lint",
+		label: detection.usesVitePlus ? "oxlint plugin (vp lint reads the `lint` block in the Vite config)" : "oxlint plugin (the oxlint binary reads oxlint.config.ts)",
+		available: true,
+		configured,
+		note: configured ? "already configured" : unread === null ? "" : `${unread} exists but oxlint never reads it (#3474)`,
+		defaultSelected: true
+	};
+}
+function bundlerOffer(detection) {
+	if (detection.framework === "nuxt") return {
+		id: "bundler",
+		label: "nuxt module (@vizejs/nuxt)",
+		available: detection.nuxtConfig !== null,
+		configured: detection.hasVizeNuxtModule,
+		note: detection.hasVizeNuxtModule ? "already configured" : detection.nuxtConfig === null ? "no nuxt.config file to add @vizejs/nuxt to" : "",
+		defaultSelected: detection.nuxtConfig !== null
+	};
+	if (detection.framework === "vite") {
+		const single = detection.viteConfigs.length === 1;
+		return {
+			id: "bundler",
+			label: "vite plugin (@vizejs/vite-plugin)",
+			available: single,
+			configured: detection.hasVizeVitePlugin,
+			note: detection.hasVizeVitePlugin ? "already configured" : single ? "" : `several Vite configs (${detection.viteConfigs.join(", ")})`,
+			defaultSelected: single
+		};
+	}
+	return {
+		id: "bundler",
+		label: "vite plugin or nuxt module",
+		available: false,
+		configured: false,
+		note: "no vite.config or nuxt.config found; the other features work without one",
+		defaultSelected: false
+	};
+}
+function fmtOffer(detection) {
+	const configured = detection.vizeConfig !== null && "vize:fmt" in detection.scripts;
+	return {
+		id: "fmt",
+		label: "fmt (vize fmt)",
+		available: true,
+		configured,
+		note: configured ? "already configured" : "",
+		defaultSelected: true
+	};
+}
+function typecheckOffer(detection) {
+	const configured = detection.vizeConfig !== null && "vize:check" in detection.scripts;
+	return {
+		id: "typecheck",
+		label: "typecheck (vize check)",
+		available: detection.tsconfig !== null,
+		configured,
+		note: configured ? "already configured" : detection.tsconfig === null ? "needs a tsconfig.json" : "",
+		defaultSelected: detection.tsconfig !== null
+	};
+}
+function editorOffer(detection) {
+	return {
+		id: "editor",
+		label: "editor extension (.vscode/extensions.json recommendation)",
+		available: true,
+		configured: detection.vscodeRecommendsVize,
+		note: detection.vscodeRecommendsVize ? "already recommended" : "",
+		defaultSelected: true
+	};
+}
+//#endregion
+//#region src/init/args.ts
+const PACKAGE_MANAGERS = [
+	"pnpm",
+	"npm",
+	"yarn",
+	"bun",
+	"vp"
+];
+/**
+* Parses `vize init` arguments.
+*
+* `--yes` is the only switch that disables prompting. Per-feature flags without
+* it still prompt, using the flags as the pre-ticked defaults, which keeps a
+* half-typed command from silently writing files.
+*/
+function parseInitArgs(args) {
+	const overrides = {};
+	let root = null;
+	let bundlerOverride = null;
+	let yes = false;
+	let dryRun = false;
+	let install = true;
+	let packageManager = null;
+	let help = false;
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "-h" || arg === "--help") {
+			help = true;
+			continue;
+		}
+		if (arg === "-y" || arg === "--yes") {
+			yes = true;
+			continue;
+		}
+		if (arg === "--dry-run") {
+			dryRun = true;
+			continue;
+		}
+		if (arg === "--no-install") {
+			install = false;
+			continue;
+		}
+		if (arg === "--package-manager") {
+			packageManager = requirePackageManager(args[index + 1]);
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("--package-manager=")) {
+			packageManager = requirePackageManager(arg.slice(18));
+			continue;
+		}
+		if (arg === "--vite" || arg === "--nuxt") {
+			bundlerOverride = arg === "--vite" ? "vite" : "nuxt";
+			overrides.bundler = true;
+			continue;
+		}
+		const feature = matchFeatureFlag(arg);
+		if (feature !== null) {
+			overrides[feature.id] = feature.enabled;
+			continue;
+		}
+		if (arg.startsWith("-")) throw new Error(`Unknown init option: ${arg}`);
+		if (root !== null) throw new Error(`Unexpected init argument: ${arg}`);
+		root = arg;
+	}
+	return {
+		root,
+		overrides,
+		bundlerOverride,
+		yes,
+		dryRun,
+		install,
+		packageManager,
+		help
+	};
+}
+function matchFeatureFlag(arg) {
+	for (const id of FEATURE_IDS) {
+		if (arg === `--${id}`) return {
+			id,
+			enabled: true
+		};
+		if (arg === `--no-${id}`) return {
+			id,
+			enabled: false
+		};
+	}
+	return null;
+}
+function requirePackageManager(value) {
+	if (value === void 0 || value.startsWith("-")) throw new Error("--package-manager requires a value");
+	if (!PACKAGE_MANAGERS.includes(value)) throw new Error(`Unknown package manager: ${value}. Expected one of ${PACKAGE_MANAGERS.join(", ")}`);
+	return value;
+}
+function initHelp() {
+	return `Select, install, and configure Vize in an existing project
+
+Usage: vize init [ROOT] [OPTIONS]
+
+Arguments:
+  [ROOT]  Project root containing package.json (default: current directory)
+
+Options:
+  -y, --yes                  Accept the detected selection without prompting
+      --lint / --no-lint     oxlint plugin
+      --vite                 vite plugin (forces the Vite target)
+      --nuxt                 nuxt module (forces the Nuxt target)
+      --bundler/--no-bundler vite plugin or nuxt module, auto-detected
+      --fmt / --no-fmt       vize fmt
+      --typecheck            vize check (needs a tsconfig.json)
+      --no-typecheck
+      --editor / --no-editor .vscode/extensions.json recommendation
+      --dry-run              Print the plan without writing anything
+      --no-install           Write configuration without installing dependencies
+      --package-manager <PM> One of ${PACKAGE_MANAGERS.join(", ")} (default: detected)
+  -h, --help                 Print help
+
+Without --yes, init prompts. A non-TTY stdin is detected and refused rather than
+hung, so CI must pass --yes together with the per-feature flags it wants.
+`;
+}
+//#endregion
+//#region src/init/detect.ts
+const NUXT_CONFIG_FILES = [
+	"nuxt.config.ts",
+	"nuxt.config.mts",
+	"nuxt.config.js",
+	"nuxt.config.mjs"
+];
+const VITE_CONFIG_FILES$1 = [
+	"vite.config.ts",
+	"vite.config.mts",
+	"vite.config.js",
+	"vite.config.mjs"
+];
+/**
+* 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.
+*/
+function detectPackageManager(root) {
+	const exists = (name) => 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) {
+	let source;
+	try {
+		source = fs.readFileSync(path.join(root, "package.json"), "utf8");
+	} catch {
+		return null;
+	}
+	let field;
+	try {
+		field = JSON.parse(source).packageManager;
+	} catch {
+		return null;
+	}
+	if (typeof field !== "string") return null;
+	for (const candidate of [
+		"pnpm",
+		"yarn",
+		"bun",
+		"npm"
+	]) 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.
+*/
+function withFramework(detection, framework) {
+	return framework === null || framework === detection.framework ? detection : {
+		...detection,
+		framework
+	};
+}
+function detectProject(root) {
+	const packagePath = path.join(root, "package.json");
+	const packageJson = parsePackageJson(packagePath, readRequiredFile(packagePath, "No package.json found"));
+	const dependencies = dependencyNames(packageJson);
+	const scripts = readScripts(packageJson);
+	const nuxtConfig = findExisting(root, NUXT_CONFIG_FILES);
+	const viteConfigs = VITE_CONFIG_FILES$1.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, viteConfigs, dependencies) {
+	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, viteSource, scripts) {
+	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) {
+	let source;
+	try {
+		source = fs.readFileSync(path.join(root, ".vscode", "extensions.json"), "utf8");
+	} catch {
+		return false;
+	}
+	return source.includes("ubugeeei.vize");
+}
+function readScripts(packageJson) {
+	const scripts = packageJson.scripts;
+	if (typeof scripts !== "object" || scripts === null || Array.isArray(scripts)) return {};
+	const entries = {};
+	for (const [name, command] of Object.entries(scripts)) if (typeof command === "string") entries[name] = command;
+	return entries;
+}
+function findExisting(root, candidates) {
+	return candidates.find((candidate) => fs.existsSync(path.join(root, candidate))) ?? null;
+}
+function readFile(root, relative) {
+	return fs.readFileSync(path.join(root, relative), "utf8");
+}
+//#endregion
+//#region src/init/plan-types.ts
+function createPlanDraft() {
+	return {
+		files: [],
+		createdFiles: [],
+		updatedFiles: [],
+		features: [],
+		dependencies: /* @__PURE__ */ new Set()
+	};
+}
+function skipped(id, detail = "not selected") {
+	return {
+		id,
+		outcome: "skipped",
+		detail,
+		snippet: null
+	};
+}
+//#endregion
+//#region src/init/plan-bundler.ts
+/**
+* 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.
+*/
+function planBundler(detection, viteDraft, draft) {
+	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, draft) {
+	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 injected = injectNuxtModule(fs.readFileSync(path.join(detection.root, detection.nuxtConfig), "utf8"));
+	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
+	});
+}
+//#endregion
+//#region src/init/plan-editor.ts
+const EXTENSIONS_FILE = path.join(".vscode", "extensions.json");
+/**
+* Plans the editor recommendation.
+*
+* `.vscode/extensions.json` is preferred over `code --install-extension` because
+* it is checked in, applies to everyone on the project, and changes nothing on
+* the machine running `init`. An existing file is merged, never replaced: it
+* usually carries the team's other recommendations.
+*/
+function planEditorFile(detection, files, createdFiles, updatedFiles) {
+	const filename = path.join(detection.root, ".vscode", "extensions.json");
+	let source;
+	try {
+		source = fs.readFileSync(filename, "utf8");
+	} catch {
+		files.push({
+			filename,
+			source: renderVscodeExtensions(2)
+		});
+		createdFiles.push(EXTENSIONS_FILE);
+		return {
+			id: "editor",
+			outcome: "configured",
+			detail: `writes ${EXTENSIONS_FILE} recommending ${VSCODE_EXTENSION_ID}`,
+			snippet: null
+		};
+	}
+	const merged = mergeRecommendation(source);
+	if (merged === null) return {
+		id: "editor",
+		outcome: "blocked",
+		detail: `${EXTENSIONS_FILE} is not a plain JSON object this tool can extend safely`,
+		snippet: `"recommendations": ["${VSCODE_EXTENSION_ID}"]`
+	};
+	if (merged === source) return {
+		id: "editor",
+		outcome: "unchanged",
+		detail: `${EXTENSIONS_FILE} already recommends ${VSCODE_EXTENSION_ID}`,
+		snippet: null
+	};
+	files.push({
+		filename,
+		source: merged
+	});
+	updatedFiles.push(EXTENSIONS_FILE);
+	return {
+		id: "editor",
+		outcome: "configured",
+		detail: `adds ${VSCODE_EXTENSION_ID} to ${EXTENSIONS_FILE}`,
+		snippet: null
+	};
+}
+/**
+* Adds the recommendation to an existing file, preserving its other keys and its
+* indentation. Returns the input unchanged when the id is already listed, and
+* `null` when the file is not a JSON object with an array of string
+* recommendations.
+*/
+function mergeRecommendation(source) {
+	let parsed;
+	try {
+		parsed = JSON.parse(source);
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+	const document = parsed;
+	const existing = document.recommendations;
+	if (existing !== void 0 && !isStringArray(existing)) return null;
+	const recommendations = existing ?? [];
+	if (recommendations.includes("ubugeeei.vize")) return source;
+	document.recommendations = [...recommendations, VSCODE_EXTENSION_ID];
+	return `${JSON.stringify(document, null, detectJsonIndent(source))}\n`;
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+//#endregion
+//#region src/init/plan-lint.ts
+/**
+* Plans the Oxlint wiring into whichever file the project's lint command reads.
+*
+* The single rule this function exists to enforce: never write an Oxlint config
+* the project's own lint command ignores. `vp lint` and `vp check` read only the
+* `lint` block of the Vite config; `oxlint` and `oxlint-vize` read only their own
+* config file. Writing the wrong one produces a project that looks configured,
+* reports zero `vize/*` diagnostics and exits `0` -- #3389, fixed in #3407.
+*
+* When the required file cannot be edited safely this returns a `blocked`
+* result and writes nothing at all. Falling back to the *other* file would be
+* the bug: the user would see a success message and get silence from the linter.
+*
+* @returns the possibly-edited Vite config source, or the input unchanged.
+*/
+function planLint(detection, lintTarget, viteDraft, draft) {
+	if (lintTarget.blockedReason !== null) {
+		draft.features.push({
+			id: "lint",
+			outcome: "blocked",
+			detail: `vp lint reads the \`lint\` block in the Vite config, but ${lintTarget.blockedReason}. Nothing was written: an unconfigured project fails loudly, while an Oxlint config vp lint never reads reports zero Vize diagnostics and exits 0`,
+			snippet: lintTarget.blockedSnippet
+		});
+		return viteDraft;
+	}
+	let source = viteDraft;
+	const wrote = [];
+	if (lintTarget.viteConfig !== null && !detection.hasVitePlusLintBlock && source !== null) {
+		const injected = injectViteLint(source);
+		if (injected !== null) {
+			source = injected;
+			wrote.push(lintTarget.viteConfig);
+		}
+	}
+	if (lintTarget.oxlintConfig !== null) {
+		draft.files.push({
+			filename: path.join(detection.root, INIT_OXLINT_CONFIG_FILE),
+			source: INIT_OXLINT_CONFIG
+		});
+		draft.createdFiles.push(INIT_OXLINT_CONFIG_FILE);
+		wrote.push(INIT_OXLINT_CONFIG_FILE);
+	}
+	draft.features.push({
+		id: "lint",
+		outcome: wrote.length > 0 ? "configured" : "unchanged",
+		detail: wrote.length > 0 ? `${lintTarget.reason}; writes ${wrote.join(" and ")}` : lintTarget.reason,
+		snippet: null
+	});
+	return source;
+}
+//#endregion
+//#region src/init/plan-project.ts
+/** Scripts each feature contributes, reusing the command strings `setup` ships. */
+const FEATURE_SCRIPTS = {
+	lint: ["vize:lint"],
+	bundler: [],
+	fmt: ["vize:fmt", "vize:fmt:fix"],
+	typecheck: ["vize:check"],
+	editor: []
+};
+/**
+* Plans `vize.config.ts` and the fmt/typecheck feature results.
+*
+* Only selected features contribute a block, so asking for the formatter alone
+* does not hand the project a type checker it never opted into. An existing Vize
+* config is never rewritten: merging into a user's config is exactly the kind of
+* guess that loses their settings.
+*/
+function planVizeConfig(detection, selection, draft) {
+	for (const id of ["fmt", "typecheck"]) {
+		if (!selection[id]) {
+			draft.features.push(id === "typecheck" && detection.tsconfig === null ? skipped(id, "no tsconfig.json, so vize check has nothing to check") : skipped(id));
+			continue;
+		}
+		if (id === "typecheck" && detection.tsconfig === null) {
+			draft.features.push({
+				id,
+				outcome: "blocked",
+				detail: "vize check needs a tsconfig.json; none was found",
+				snippet: null
+			});
+			continue;
+		}
+		draft.features.push({
+			id,
+			outcome: detection.vizeConfig === null ? "configured" : "unchanged",
+			detail: detection.vizeConfig === null ? "writes vize.config.ts" : `${detection.vizeConfig} already exists and was left unchanged`,
+			snippet: null
+		});
+	}
+	if (!(selection.lint || selection.fmt || selection.typecheck) || detection.vizeConfig !== null) return;
+	draft.files.push({
+		filename: path.join(detection.root, "vize.config.ts"),
+		source: renderVizeConfig({
+			lint: selection.lint,
+			fmt: selection.fmt,
+			typecheck: selection.typecheck && detection.tsconfig !== null,
+			vite: detection.framework === "vite"
+		})
+	});
+	draft.createdFiles.push("vize.config.ts");
+}
+/**
+* Adds the scripts the selected features need.
+*
+* A script the project already defines is left alone, whatever its value: the
+* user's version of `vize:lint` outranks the default, and rewriting it would
+* make a second `init` run destructive.
+*/
+function planScripts(detection, selection, draft) {
+	const wanted = [];
+	for (const id of [
+		"lint",
+		"fmt",
+		"typecheck"
+	]) {
+		if (!selection[id] || id === "typecheck" && detection.tsconfig === null) continue;
+		wanted.push(...FEATURE_SCRIPTS[id]);
+	}
+	const missing = wanted.filter((name) => !(name in detection.scripts));
+	if (missing.length === 0) return [];
+	const packagePath = path.join(detection.root, "package.json");
+	const source = fs.readFileSync(packagePath, "utf8");
+	const packageJson = parsePackageJson(packagePath, source);
+	const scripts = { ...detection.scripts };
+	for (const name of missing) scripts[name] = DEFAULT_SCRIPTS[name];
+	packageJson.scripts = scripts;
+	draft.files.push({
+		filename: packagePath,
+		source: `${JSON.stringify(packageJson, null, detectJsonIndent(source))}\n`
+	});
+	draft.updatedFiles.push("package.json");
+	return missing;
+}
+//#endregion
+//#region src/init/plan.ts
+/** Dev dependencies each feature needs. */
+const FEATURE_DEPENDENCIES = {
+	lint: ["oxlint", "oxlint-plugin-vize"],
+	bundler: [],
+	fmt: ["vize"],
+	typecheck: ["vize"],
+	editor: []
+};
+const INSTALL_ARGS = {
+	pnpm: ["add", "-D"],
+	yarn: ["add", "-D"],
+	bun: ["add", "-D"],
+	npm: ["install", "-D"],
+	vp: ["add", "-D"]
+};
+const FEATURE_ORDER = [
+	"lint",
+	"bundler",
+	"fmt",
+	"typecheck",
+	"editor"
+];
+/**
+* Builds the full plan without touching the filesystem.
+*
+* Planning is separated from execution so `--dry-run`, the interactive
+* confirmation and the tests all inspect the same object the writer consumes;
+* a plan that is correct in `--dry-run` and wrong on disk is not possible.
+*/
+function planInit(options) {
+	const { detection, selection } = options;
+	const draft = createPlanDraft();
+	const viteSource = readSingleViteConfig(detection);
+	const lintTarget = resolveLintTarget({
+		detection,
+		viteSource
+	});
+	let viteDraft = viteSource;
+	if (selection.lint) {
+		viteDraft = planLint(detection, lintTarget, viteDraft, draft);
+		addAll(draft.dependencies, FEATURE_DEPENDENCIES.lint);
+	} else draft.features.push(skipped("lint"));
+	if (selection.bundler) viteDraft = planBundler(detection, viteDraft, draft);
+	else draft.features.push(skipped("bundler"));
+	if (viteSource !== null && viteDraft !== null && viteDraft !== viteSource) {
+		const filename = detection.viteConfigs[0];
+		draft.files.push({
+			filename: path.join(detection.root, filename),
+			source: viteDraft
+		});
+		draft.updatedFiles.push(filename);
+	}
+	planVizeConfig(detection, selection, draft);
+	for (const id of ["fmt", "typecheck"]) if (selection[id]) addAll(draft.dependencies, FEATURE_DEPENDENCIES[id]);
+	draft.features.push(selection.editor ? planEditorFile(detection, draft.files, draft.createdFiles, draft.updatedFiles) : skipped("editor"));
+	const addedScripts = planScripts(detection, selection, draft);
+	return {
+		root: detection.root,
+		detection,
+		lintTarget,
+		features: sortFeatures(draft.features),
+		files: draft.files,
+		createdFiles: draft.createdFiles,
+		updatedFiles: draft.updatedFiles,
+		addedScripts,
+		commands: planCommands(detection, draft.dependencies, options)
+	};
+}
+/**
+* The install commands, as a list so callers can assert on them.
+*
+* Exactly one command is emitted, or none when every dependency is already
+* declared -- which is what makes a second `init` run a no-op.
+*/
+function planCommands(detection, dependencies, options) {
+	if (!options.install) return [];
+	const missing = [...dependencies].filter((name) => !detection.dependencies.has(name)).sort();
+	if (missing.length === 0) return [];
+	const command = resolveInstaller(detection, options.packageManager);
+	return [{
+		command,
+		args: [...INSTALL_ARGS[command], ...missing],
+		cwd: detection.root
+	}];
+}
+/**
+* Installer used for the one install command.
+*
+* A Vite+ project gets `vp add`, matching `setup` and the project's own
+* workflow. Otherwise the package manager comes from the same lockfile rules
+* `detect_package_manager` uses on the Rust side, defaulting to npm when
+* nothing identifies one.
+*/
+function resolveInstaller(detection, override) {
+	if (override !== void 0) return override;
+	if (detection.usesVitePlus) return "vp";
+	return detection.packageManager ?? "npm";
+}
+function readSingleViteConfig(detection) {
+	if (detection.viteConfigs.length !== 1) return null;
+	return fs.readFileSync(path.join(detection.root, detection.viteConfigs[0]), "utf8");
+}
+function addAll(target, values) {
+	for (const value of values) target.add(value);
+}
+function sortFeatures(features) {
+	return [...features].sort((left, right) => FEATURE_ORDER.indexOf(left.id) - FEATURE_ORDER.indexOf(right.id));
+}
+//#endregion
+//#region src/init/prompt.ts
+/** True when stdin cannot answer a prompt, so `init` must not ask one. */
+function isNonInteractive(stream) {
+	return stream.isTTY !== true;
+}
+/**
+* Wraps `node:readline` so a closed input resolves instead of hanging.
+*
+* `rl.question` never invokes its callback when stdin reaches EOF first. Left
+* alone that leaves `init`'s promise permanently pending, and the process exits
+* `0` having written nothing -- a silent no-op that looks like success. Resolving
+* to `null` on close turns that into an explicit cancellation.
+*/
+function createPromptDeps(io) {
+	const rl = readline.createInterface({
+		input: io.input,
+		output: io.output
+	});
+	let closed = false;
+	rl.on("close", () => {
+		closed = true;
+	});
+	return {
+		...io,
+		question: (query) => new Promise((resolve) => {
+			if (closed) {
+				resolve(null);
+				return;
+			}
+			let settled = false;
+			const onClose = () => {
+				if (!settled) {
+					settled = true;
+					resolve(null);
+				}
+			};
+			rl.once("close", onClose);
+			rl.question(query, (answer) => {
+				if (settled) return;
+				settled = true;
+				rl.removeListener("close", onClose);
+				resolve(answer);
+			});
+		}),
+		close: () => {
+			rl.close();
+		}
+	};
+}
+/** Runs the checklist. Returns `null` when the input ended before confirmation. */
+async function selectFeatures(offers, initial, deps) {
+	const selection = { ...initial };
+	const toggleable = offers.filter((offer) => offer.available);
+	for (;;) {
+		deps.output.write(renderChecklist(offers, selection));
+		const raw = await deps.question("> ");
+		if (raw === null) return null;
+		const answer = raw.trim();
+		if (answer === "") return selection;
+		const indexes = parseIndexes(answer, toggleable.length);
+		if (indexes === null) {
+			deps.output.write(`Enter numbers between 1 and ${toggleable.length}, or press Enter to accept.\n`);
+			continue;
+		}
+		for (const index of indexes) {
+			const offer = toggleable[index];
+			selection[offer.id] = !selection[offer.id];
+		}
+	}
+}
+/** Yes/no confirmation. A closed input counts as "no", never as "yes". */
+async function confirm(query, deps) {
+	const raw = await deps.question(`${query} [Y/n] `);
+	if (raw === null) return false;
+	const answer = raw.trim().toLowerCase();
+	return answer === "" || answer === "y" || answer === "yes";
+}
+function renderChecklist(offers, selection) {
+	const lines = [
+		"",
+		"Select the features to configure.",
+		"Type the numbers to toggle (space or comma separated), then press Enter.",
+		""
+	];
+	let position = 0;
+	for (const offer of offers) {
+		if (!offer.available) {
+			lines.push(`     -  ${offer.label}${offer.note === "" ? "" : ` (${offer.note})`}`);
+			continue;
+		}
+		position += 1;
+		const mark = selection[offer.id] ? "x" : " ";
+		const note = offer.note === "" ? "" : ` (${offer.note})`;
+		lines.push(`  ${position}. [${mark}] ${offer.label}${note}`);
+	}
+	lines.push("");
+	return `${lines.join("\n")}\n`;
+}
+/** Parses a toggle answer into zero-based indexes, or `null` when any entry is out of range. */
+function parseIndexes(answer, count) {
+	const tokens = answer.split(/[\s,]+/u).filter((token) => token !== "");
+	const indexes = [];
+	for (const token of tokens) {
+		if (!/^\d+$/u.test(token)) return null;
+		const value = Number.parseInt(token, 10);
+		if (value < 1 || value > count) return null;
+		indexes.push(value - 1);
+	}
+	return indexes.length === 0 ? null : indexes;
+}
+//#endregion
+//#region src/init/report.ts
+const PREFIX = "[vize init]";
+/**
+* Detection summary, printed before any prompt.
+*
+* Users need to see what `init` concluded before they are asked to act on it;
+* an unexpected line here is the cheapest place to catch a wrong root or a
+* missing lockfile.
+*/
+function renderDetection(detection) {
+	return `${[
+		`${PREFIX} detected in ${detection.root}:`,
+		`  framework:       ${describeFramework(detection)}`,
+		`  package manager: ${detection.packageManager ?? "none detected (defaulting to npm)"}`,
+		`  language:        ${detection.typescript ? "TypeScript" : "JavaScript"}${detection.tsconfig === null ? " (no tsconfig.json)" : " (tsconfig.json)"}`,
+		`  lint command:    ${detection.usesVitePlus ? "vp lint" : "oxlint"}`,
+		`  vize config:     ${detection.vizeConfig ?? "none"}`,
+		`  oxlint config:   ${describeOxlintConfig(detection)}`
+	].join("\n")}\n`;
+}
+function describeFramework(detection) {
+	if (detection.framework === "nuxt") return `Nuxt (${detection.nuxtConfig ?? "nuxt dependency, no nuxt.config"})`;
+	if (detection.framework === "vite") {
+		const configs = detection.viteConfigs.join(", ");
+		return detection.usesVitePlus ? `Vite+ (${configs})` : `Vite (${configs})`;
+	}
+	return "none (no vite.config or nuxt.config)";
+}
+function describeOxlintConfig(detection) {
+	const unread = unreadOxlintConfig(detection);
+	if (unread !== null) return `${unread} — present but oxlint does not read this name (#3474)`;
+	return detection.oxlintConfig ?? "none";
+}
+/**
+* The full plan.
+*
+* Printed before anything is written in both modes, so the wording is what the
+* run is about to do, not what it has done. `--dry-run` differs only in stopping
+* afterwards.
+*/
+function renderPlan(plan, dryRun) {
+	const verb = dryRun ? "would" : "will";
+	const lines = [`${PREFIX} plan:`];
+	for (const feature of plan.features) lines.push(`  ${feature.id.padEnd(9)} ${feature.outcome.padEnd(10)} ${feature.detail}`);
+	for (const filename of plan.createdFiles) lines.push(`${PREFIX} ${verb} create ${filename}`);
+	for (const filename of plan.updatedFiles) lines.push(`${PREFIX} ${verb} update ${filename}`);
+	if (plan.addedScripts.length > 0) lines.push(`${PREFIX} ${verb} add scripts: ${plan.addedScripts.join(", ")}`);
+	for (const command of plan.commands) lines.push(`${PREFIX} ${verb} run: ${command.command} ${command.args.join(" ")}`);
+	if (plan.createdFiles.length + plan.updatedFiles.length + plan.commands.length === 0) lines.push(`${PREFIX} nothing to do; the project is already configured`);
+	return `${lines.join("\n")}\n`;
+}
+/**
+* Snippets for anything `init` refused to edit.
+*
+* A blocked feature is deliberately loud. The alternative for the lint feature
+* would be writing an Oxlint config the project's lint command never reads,
+* which reports zero Vize diagnostics and exits 0 (#3389).
+*/
+function renderBlocked(plan) {
+	const blocked = plan.features.filter((feature) => feature.outcome === "blocked");
+	if (blocked.length === 0) return "";
+	const lines = [];
+	for (const feature of blocked) {
+		lines.push(`${PREFIX} ${feature.id}: NOT configured — ${feature.detail}`);
+		if (feature.snippet !== null) lines.push("", indent(feature.snippet), "");
+	}
+	return `${lines.join("\n")}\n`;
+}
+function renderEditors() {
+	const lines = [`${PREFIX} editor integrations shipped with Vize:`];
+	for (const integration of EDITOR_INTEGRATIONS) lines.push(`  ${integration}`);
+	return `${lines.join("\n")}\n`;
+}
+/**
+* Printed when the prompt ends without a confirmation.
+*
+* Covers both a declined confirmation and an input stream that closed
+* mid-prompt. Saying so is what keeps a closed stdin from looking like a
+* successful run that happened to change nothing.
+*/
+function renderCancelled() {
+	return `${PREFIX} cancelled; nothing was written.\n`;
+}
+function renderNonInteractiveRefusal() {
+	return `${PREFIX} stdin is not a TTY, so init will not prompt.\n${PREFIX} pass --yes with the features you want, for example:\n${PREFIX}   vize init --yes --lint --vite --fmt --typecheck --editor\n${PREFIX} or run with --dry-run to print the plan without writing.\n`;
+}
+function indent(source) {
+	return source.split("\n").map((line) => line === "" ? line : `    ${line}`).join("\n").trimEnd();
+}
+//#endregion
+//#region src/init.ts
+/**
+* Resolves the feature selection from detection, flags, and -- when the terminal
+* allows it -- the user.
+*
+* A non-TTY stdin without `--yes` returns `null`: refusing is the only correct
+* answer, because prompting would hang a CI job forever.
+*/
+async function resolveSelection(detection, args, deps) {
+	const offers = offerFeatures(detection);
+	const withOverrides = { ...defaultSelection(offers) };
+	for (const [id, enabled] of Object.entries(args.overrides)) withOverrides[id] = enabled;
+	const selection = withOverrides;
+	if (args.yes) return selection;
+	if (deps.promptDeps === void 0 && isNonInteractive(deps.stdin)) {
+		deps.output(renderNonInteractiveRefusal());
+		return null;
+	}
+	const owned = deps.promptDeps === void 0 ? createPromptDeps({
+		input: deps.stdin,
+		output: process.stdout
+	}) : null;
+	const promptDeps = deps.promptDeps ?? owned;
+	try {
+		const chosen = await selectFeatures(offers, selection, promptDeps);
+		if (chosen !== null && await confirm("Apply this selection?", promptDeps)) return chosen;
+		deps.output(renderCancelled());
+		return null;
+	} finally {
+		owned?.close?.();
+	}
+}
+/**
+* Runs `init` end to end.
+*
+* Detection is reported before anything is decided, the plan is reported before
+* anything is written, and a blocked feature is reported as NOT configured
+* rather than quietly downgraded.
+*/
+async function initProject(options) {
+	const args = parseInitArgs(options.args ?? []);
+	const output = options.output ?? ((chunk) => process.stdout.write(chunk));
+	const detection = withFramework(detectProject(path.resolve(args.root ?? options.root)), args.bundlerOverride);
+	output(renderDetection(detection));
+	const selection = await resolveSelection(detection, args, {
+		output,
+		stdin: options.stdin ?? process.stdin,
+		promptDeps: options.promptDeps
+	});
+	if (selection === null) return null;
+	const plan = planInit({
+		detection,
+		selection,
+		install: args.install,
+		packageManager: args.packageManager ?? void 0
+	});
+	output(renderPlan(plan, args.dryRun));
+	output(renderBlocked(plan));
+	if (args.dryRun) return plan;
+	writePlannedFiles$1(plan, options.writeFile ?? writeProjectFile);
+	const runCommand = options.runCommand ?? runInitCommand;
+	for (const command of plan.commands) runCommand(command);
+	if (selection.editor) output(renderEditors());
+	return plan;
+}
+async function runInitCli(args) {
+	if (parseInitArgs(args).help) {
+		process.stdout.write(initHelp());
+		return;
+	}
+	const plan = await initProject({
+		root: process.cwd(),
+		args
+	});
+	if (plan === null) {
+		process.exitCode = 1;
+		return;
+	}
+	if (plan.features.some((feature) => feature.outcome === "blocked")) process.exitCode = 1;
+}
+/**
+* Default writer.
+*
+* Creates the parent directory first so `.vscode/extensions.json` works in a
+* project that has never had a `.vscode` folder, then reuses `setup`'s atomic
+* write so a crash mid-run cannot leave a half-written config behind.
+*/
+function writeProjectFile(filename, source) {
+	fs.mkdirSync(path.dirname(filename), { recursive: true });
+	atomicWriteFile(filename, source);
+}
+function writePlannedFiles$1(plan, writeFile) {
+	const written = [];
+	for (const file of plan.files) {
+		try {
+			writeFile(file.filename, file.source);
+		} catch (error) {
+			if (written.length === 0) throw error;
+			throw new Error(`init partially completed: wrote ${written.join(", ")} before ${path.relative(plan.root, file.filename)} failed. Run init again to finish.`, { cause: error });
+		}
+		written.push(path.relative(plan.root, file.filename));
+	}
+}
+function runInitCommand(command) {
+	execFileSync(command.command, [...command.args], {
+		cwd: command.cwd,
+		stdio: "inherit"
+	});
+}
+//#endregion
 //#region src/setup/vite.ts
 const VITE_CONFIG_FILES = [
 	"vite.config.ts",
@@ -386,14 +1968,18 @@ function writePlannedFiles(root, plannedFiles, writeFile) {
 //#endregion
 //#region src/cli.ts
 const require = createRequire(import.meta.url);
+function fail(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	process.stderr.write(`[vize] ${message}\n`);
+	process.exitCode = 1;
+}
 try {
 	const args = process.argv.slice(2);
 	if (args[0] === "setup") runSetupCli(args.slice(1));
+	else if (args[0] === "init") runInitCli(args.slice(1)).catch(fail);
 	else require("@vizejs/native").runCli(args);
 } catch (error) {
-	const message = error instanceof Error ? error.message : String(error);
-	process.stderr.write(`[vize] ${message}\n`);
-	process.exitCode = 1;
+	fail(error);
 }
 //#endregion
 export {};