@isentinel/eslint-config 6.0.0-beta.2 → 6.0.0-beta.21

package/dist/cli.mjs

@@ -1 +1,720 @@
+import { cancel, confirm, group, intro, log, multiselect, note, outro } from "@clack/prompts";
+import ansis from "ansis";
+import process from "node:process";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { existsSync, readFileSync } from "fs";
+import { execSync } from "node:child_process";
+//#region package.json
+var version = "6.0.0-beta.21";
+var package_default = {
+	name: "@isentinel/eslint-config",
+	version,
+	description: "iSentinel's ESLint config",
+	keywords: [
+		"eslint-config",
+		"roblox",
+		"roblox-ts",
+		"rbxts"
+	],
+	homepage: "https://github.com/christopher-buss/eslint-config",
+	bugs: { "url": "https://github.com/christopher-buss/eslint-config/issues" },
+	repository: {
+		"type": "git",
+		"url": "git+https://github.com/christopher-buss/eslint-config.git"
+	},
+	license: "MIT",
+	author: "Christopher Buss <christopher.buss@pm.me> (https://github.com/christopher-buss)",
+	contributors: [{
+		"name": "Anthony Fu",
+		"email": "anthonyfu117@hotmail.com",
+		"url": "https://github.com/antfu"
+	}],
+	sideEffects: false,
+	type: "module",
+	exports: {
+		".": "./dist/index.mjs",
+		"./cli": "./dist/cli.mjs",
+		"./eslint": {
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		},
+		"./formatter-agents": "./dist/formatter-agents.mjs",
+		"./oxlint": {
+			"types": "./dist/oxlint.d.mts",
+			"default": "./dist/oxlint.mjs"
+		},
+		"./package.json": "./package.json"
+	},
+	main: "./dist/index.mjs",
+	module: "./dist/index.mjs",
+	types: "./dist/index.d.mts",
+	bin: {
+		"eslint-config": "./bin/index.js",
+		"isentinel-lint": "./bin/lint.js"
+	},
+	files: ["bin", "dist"],
+	scripts: {
+		"build": "nr gen && tsdown && node scripts/check-dist.ts",
+		"build:inspector": "pnpm build && pnpm dlx @eslint/config-inspector build --config eslint-inspector.config.ts --out-dir ./.eslint-config-inspector",
+		"dev": "npx @eslint/config-inspector --config eslint-inspector.config.ts",
+		"gen": "node scripts/typegen.ts && node scripts/typegen-oxlint.ts && node scripts/typegen-defaults.ts && node scripts/typegen-defaults-oxlint.ts && node scripts/versiongen.ts",
+		"postgen": "echo 'Generation complete!'",
+		"lint": "concurrently 'oxlint' 'eslint --cache'",
+		"lint:ci": "concurrently 'oxlint' 'eslint --cache --cache-strategy content'",
+		"oxlint": "oxlint",
+		"prepack": "nr build",
+		"release": "bumpp",
+		"stub": "tsdown",
+		"test": "nr gen && vitest run",
+		"test:watch": "vitest",
+		"typecheck": "tsc --noEmit",
+		"validate:oxlint": "node scripts/validate-oxlint.ts",
+		"watch": "tsdown --watch --dts"
+	},
+	dependencies: {
+		"@antfu/install-pkg": "catalog:prod",
+		"@clack/prompts": "catalog:prod",
+		"@cspell/eslint-plugin": "catalog:prod",
+		"@e18e/eslint-plugin": "catalog:prod",
+		"@eslint-community/eslint-plugin-eslint-comments": "catalog:prod",
+		"@eslint/markdown": "catalog:prod",
+		"@isentinel/dict-rbxts": "catalog:prod",
+		"@isentinel/dict-roblox": "catalog:prod",
+		"@oxlint/plugins": "catalog:prod",
+		"@pobammer-ts/small-rules": "catalog:prod",
+		"@stylistic/eslint-plugin": "catalog:prod",
+		"@typescript-eslint/eslint-plugin": "catalog:prod",
+		"@typescript-eslint/parser": "catalog:prod",
+		"ansis": "catalog:prod",
+		"concurrently": "catalog:prod",
+		"eslint-config-flat-gitignore": "catalog:prod",
+		"eslint-config-prettier": "catalog:prod",
+		"eslint-flat-config-utils": "catalog:prod",
+		"eslint-merge-processors": "catalog:prod",
+		"eslint-plugin-antfu": "catalog:prod",
+		"eslint-plugin-better-max-params": "catalog:prod",
+		"eslint-plugin-comment-length": "catalog:prod",
+		"eslint-plugin-de-morgan": "catalog:prod",
+		"eslint-plugin-flawless": "catalog:prod",
+		"eslint-plugin-format-lua": "catalog:prod",
+		"eslint-plugin-import-lite": "catalog:prod",
+		"eslint-plugin-jsdoc": "catalog:prod",
+		"eslint-plugin-jsonc": "catalog:prod",
+		"eslint-plugin-oxfmt": "catalog:prod",
+		"eslint-plugin-package-json": "catalog:prod",
+		"eslint-plugin-perfectionist": "catalog:prod",
+		"eslint-plugin-pnpm": "catalog:prod",
+		"eslint-plugin-promise": "catalog:prod",
+		"eslint-plugin-roblox-ts": "catalog:prod",
+		"eslint-plugin-sentinel": "catalog:prod",
+		"eslint-plugin-sonarjs": "catalog:prod",
+		"eslint-plugin-toml": "catalog:prod",
+		"eslint-plugin-unicorn": "catalog:prod",
+		"eslint-plugin-unused-imports": "catalog:prod",
+		"eslint-plugin-yml": "catalog:prod",
+		"file-entry-cache": "catalog:prod",
+		"find-up-simple": "catalog:prod",
+		"globals": "catalog:prod",
+		"jsonc-eslint-parser": "catalog:prod",
+		"local-pkg": "catalog:prod",
+		"oxfmt": "catalog:prod",
+		"oxlint-plugin-eslint": "catalog:prod",
+		"oxlint-plugin-oxlint-comments": "catalog:prod",
+		"prettier": "catalog:prod",
+		"semver": "catalog:prod",
+		"toml-eslint-parser": "catalog:prod",
+		"yaml-eslint-parser": "catalog:prod",
+		"yargs": "catalog:prod"
+	},
+	devDependencies: {
+		"@antfu/ni": "catalog:dev",
+		"@eslint-react/shared": "catalog:dev",
+		"@eslint/config-inspector": "catalog:dev",
+		"@isentinel/eslint-config": "workspace:*",
+		"@isentinel/tsconfig": "catalog:dev",
+		"@stylistic/eslint-plugin-migrate": "catalog:dev",
+		"@total-typescript/shoehorn": "catalog:dev",
+		"@types/node": "catalog:dev",
+		"@types/picomatch": "catalog:dev",
+		"@types/semver": "catalog:dev",
+		"@types/yargs": "catalog:dev",
+		"@vitest/eslint-plugin": "catalog:peer",
+		"bumpp": "catalog:dev",
+		"eslint": "catalog:peer",
+		"eslint-plugin-erasable-syntax-only": "catalog:peer",
+		"eslint-plugin-eslint-plugin": "catalog:peer",
+		"eslint-plugin-jest": "catalog:peer",
+		"eslint-plugin-jest-extended": "catalog:peer",
+		"eslint-plugin-n": "catalog:peer",
+		"eslint-plugin-react-jsx": "catalog:peer",
+		"eslint-plugin-react-naming-convention": "catalog:peer",
+		"eslint-plugin-react-x": "catalog:peer",
+		"eslint-typegen": "catalog:dev",
+		"jiti": "catalog:dev",
+		"oxlint": "catalog:peer",
+		"oxlint-tsgolint": "catalog:peer",
+		"parse-gitignore-ts": "catalog:dev",
+		"picomatch": "catalog:dev",
+		"pnpm-workspace-yaml": "catalog:dev",
+		"publint": "catalog:dev",
+		"tsdown": "catalog:dev",
+		"type-fest": "catalog:dev",
+		"typescript": "catalog:dev",
+		"unplugin-unused": "catalog:dev",
+		"vitest": "catalog:dev"
+	},
+	peerDependencies: {
+		"@vitest/eslint-plugin": "^1.6.4",
+		"eslint": "^10.4.0",
+		"eslint-plugin-eslint-plugin": "^7.5.0",
+		"eslint-plugin-jest": "^29.15.0",
+		"eslint-plugin-jest-extended": "^3.0.0",
+		"eslint-plugin-n": "^17.0.0 || ^18.0.0",
+		"eslint-plugin-react-jsx": "^5.10.0",
+		"eslint-plugin-react-naming-convention": "^5.10.0",
+		"eslint-plugin-react-x": "^5.10.0",
+		"oxlint": ">=1.73.0",
+		"oxlint-tsgolint": ">=0.24.0"
+	},
+	peerDependenciesMeta: {
+		"@vitest/eslint-plugin": { "optional": true },
+		"eslint-plugin-eslint-plugin": { "optional": true },
+		"eslint-plugin-jest": { "optional": true },
+		"eslint-plugin-jest-extended": { "optional": true },
+		"eslint-plugin-n": { "optional": true },
+		"eslint-plugin-react-jsx": { "optional": true },
+		"eslint-plugin-react-naming-convention": { "optional": true },
+		"eslint-plugin-react-x": { "optional": true },
+		"oxlint": { "optional": true },
+		"oxlint-tsgolint": { "optional": true }
+	},
+	packageManager: "pnpm@11.15.1+sha512.81350b07e53c9538a02f1f2303b4290fa2d7be04e56e2a970c4cc4b417dc761de196edabd49d55c7dc9580db81007c44143e4e3d7e462b3000d23c255122d065",
+	engines: { "node": ">=24.12.0" },
+	publishConfig: { "access": "public" }
+};
+//#endregion
+//#region src/cli/constants.ts
+const vscodeSettingsString = `
+  // Disable the default formatter, use eslint instead
+  "prettier.enable": false,
+  "editor.formatOnSave": false,
+
+  // Auto fix
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit",
+    "source.organizeImports": "never"
+  },
+
+  // Silent the stylistic rules in you IDE, but still auto fix them
+  "eslint.rules.customizations": [
+    { "rule": "style/*", "severity": "off", "fixable": true },
+    { "rule": "format/*", "severity": "off", "fixable": true },
+    { "rule": "*fmt/*", "severity": "off", "fixable": true },
+    { "rule": "*-indent", "severity": "off", "fixable": true },
+    { "rule": "*-spacing", "severity": "off", "fixable": true },
+    { "rule": "*-spaces", "severity": "off", "fixable": true },
+    { "rule": "*-order", "severity": "off", "fixable": true },
+    { "rule": "*-dangle", "severity": "off", "fixable": true },
+    { "rule": "*-newline", "severity": "off", "fixable": true },
+    { "rule": "*quotes", "severity": "off", "fixable": true },
+    { "rule": "*semi", "severity": "off", "fixable": true }
+  ],
+
+  // Enable eslint for all supported languages
+  "eslint.validate": [
+    "typescript",
+    "typescriptreact",
+    "markdown",
+    "json",
+    "jsonc",
+    "yaml",
+	  "toml",
+	  "luau"
+  ]
+`;
+const frameworkOptions = [{
+	label: ansis.red("Test"),
+	value: "test"
+}, {
+	label: ansis.cyan("React"),
+	value: "react"
+}];
+const frameworks = frameworkOptions.map(({ value }) => value);
+const dependenciesMap = {
+	react: [
+		"eslint-plugin-react-x",
+		"eslint-plugin-react-jsx",
+		"eslint-plugin-react-naming-convention"
+	],
+	test: ["eslint-plugin-jest"]
+};
+//#endregion
+//#region src/guards.ts
+/**
+* Whether a value is an array whose every element is a string.
+*
+* @param value - The value to test.
+* @returns Whether the value is a `string` array.
+*/
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+//#endregion
+//#region node_modules/.pnpm/parse-gitignore-ts@1.0.0/node_modules/parse-gitignore-ts/dist/index.mjs
+var isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+var INVALID_PATH_CHARS_REGEX = /[<>:"|?*\n\r\t\f\x00-\x1F]/;
+var GLOBSTAR_REGEX = /(?:^|\/)[*]{2}($|\/)/;
+var MAX_PATH_LENGTH = 248;
+var isValidPath = (input) => {
+	if (typeof input === "string") return input.length <= MAX_PATH_LENGTH && !INVALID_PATH_CHARS_REGEX.test(input);
+	return false;
+};
+var split = (str) => String(str).split(/\r\n?|\n/);
+var isComment = (str) => str.startsWith("#");
+var isParsed = (input) => isObject(input) && "patterns" in input && "sections" in input;
+var patterns = (input) => {
+	return split(input).map((l) => l.trim()).filter((line) => line !== "" && !isComment(line));
+};
+var parse = (input, options = {}) => {
+	let filepath = options.path;
+	if (isParsed(input)) return input;
+	if (isValidPath(input) && existsSync(input)) {
+		filepath = input;
+		input = readFileSync(input);
+	}
+	const lines = split(input);
+	const names = /* @__PURE__ */ new Map();
+	const parsed = {
+		sections: [],
+		patterns: []
+	};
+	let section = {
+		name: "default",
+		patterns: []
+	};
+	let prev = null;
+	for (const line of lines) {
+		const value = line.trim();
+		if (value.startsWith("#")) {
+			const match = /^#+\s*(.*)\s*$/.exec(value);
+			const name = match ? match[1] : "";
+			if (prev) {
+				names.delete(prev.name);
+				prev.comment = prev.comment ? `${prev.comment}
+${value}` : value;
+				prev.name = name ? `${prev.name.trim()}
+${name.trim()}` : prev.name.trim();
+				names.set(prev.name.toLowerCase().trim(), prev);
+				continue;
+			}
+			section = {
+				name: name.trim(),
+				comment: value,
+				patterns: []
+			};
+			names.set(section.name.toLowerCase(), section);
+			parsed.sections.push(section);
+			prev = section;
+			continue;
+		}
+		if (value !== "") {
+			section.patterns.push(value);
+			parsed.patterns.push(value);
+		}
+		prev = null;
+	}
+	if (options.dedupe === true || options.unique === true) return dedupe(parsed, {
+		...options,
+		format: false
+	});
+	parsed.path = filepath;
+	parsed.input = Buffer.from(input.toString());
+	const result = parsed;
+	result.format = (opts = {}) => format(result, {
+		...options,
+		...opts
+	});
+	result.dedupe = (opts = {}) => dedupe(result, {
+		...options,
+		...opts
+	});
+	result.globs = (opts = {}) => globs(result, {
+		path: filepath,
+		...options,
+		...opts
+	});
+	return result;
+};
+var parseFile = (filepath, options = {}) => {
+	return parse(readFileSync(filepath, "utf8"), options);
+};
+var dedupe = (input, options = {}) => {
+	const parsed = parse(input, {
+		...options,
+		dedupe: false
+	});
+	const names = /* @__PURE__ */ new Map();
+	const res = {
+		sections: [],
+		patterns: []
+	};
+	const patternsSet = /* @__PURE__ */ new Set();
+	let current;
+	for (const section of parsed.sections) {
+		const { name = "", comment, patterns: patterns2 } = section;
+		const key = name.trim().toLowerCase();
+		for (const pattern of patterns2) patternsSet.add(pattern);
+		if (name && names.has(key)) {
+			current = names.get(key);
+			current.patterns = [...current.patterns, ...patterns2];
+		} else {
+			current = {
+				name,
+				comment,
+				patterns: patterns2
+			};
+			res.sections.push(current);
+			names.set(key, current);
+		}
+	}
+	for (const section of res.sections) section.patterns = [...new Set(section.patterns)];
+	res.patterns = [...patternsSet];
+	const result = res;
+	result.format = (opts = {}) => format(result, {
+		...options,
+		...opts
+	});
+	result.dedupe = (opts = {}) => dedupe(result, {
+		...options,
+		...opts
+	});
+	result.globs = (opts = {}) => globs(result, {
+		path: parsed.path,
+		...options,
+		...opts
+	});
+	return result;
+};
+var glob = (pattern, options) => {
+	if (GLOBSTAR_REGEX.test(pattern)) return pattern;
+	let relative = false;
+	if (pattern.startsWith("/")) {
+		pattern = pattern.slice(1);
+		relative = true;
+	} else if (pattern.slice(1, pattern.length - 1).includes("/")) relative = true;
+	pattern += pattern.endsWith("/") ? "**/" : "/**";
+	return relative ? pattern : `**/${pattern}`;
+};
+var globs = (input, options = {}) => {
+	const parsed = parse(input, options);
+	const result = [];
+	let index = 0;
+	const inputPatterns = parsed.patterns.concat(options.ignore || []).concat((options.unignore || []).map((p) => !p.startsWith("!") ? "!" + p : p));
+	const push = (prefix, pattern) => {
+		const prev = result[result.length - 1];
+		const type = prefix ? "unignore" : "ignore";
+		if (prev && prev.type === type) {
+			if (!prev.patterns.includes(pattern)) prev.patterns.push(pattern);
+		} else {
+			result.push({
+				type,
+				path: options.path || null,
+				patterns: [pattern],
+				index
+			});
+			index++;
+		}
+	};
+	for (let pattern of inputPatterns) {
+		let prefix = "";
+		if (pattern.startsWith("!")) {
+			pattern = pattern.slice(1);
+			prefix = "!";
+		}
+		push(prefix, pattern.startsWith("/") ? pattern.slice(1) : pattern);
+		push(prefix, glob(pattern));
+	}
+	return result;
+};
+var formatSection = (section = {
+	name: "",
+	patterns: []
+}) => {
+	const output = [section.comment || ""];
+	if (section.patterns?.length) {
+		output.push(section.patterns.join("\n"));
+		output.push("");
+	}
+	return output.join("\n");
+};
+var format = (input, options = {}) => {
+	const parsed = parse(input, options);
+	const fn = options.formatSection || formatSection;
+	const sections = parsed.sections || parsed;
+	const output = [];
+	for (const section of [].concat(sections)) output.push(fn(section));
+	return output.join("\n");
+};
+var parseGitignore = parse;
+parseGitignore.file = parseFile;
+parseGitignore.parse = parse;
+parseGitignore.dedupe = dedupe;
+parseGitignore.format = format;
+parseGitignore.globs = globs;
+parseGitignore.formatSection = formatSection;
+parseGitignore.patterns = patterns;
+var index_default = parseGitignore;
+/*!
+* parse-gitignore-ts
+* TypeScript version of parse-gitignore <https://github.com/jonschlinkert/parse-gitignore>
+* Original Copyright (c) 2015-present, Jon Schlinkert.
+* Released under the MIT License.
+*/
+//#endregion
+//#region src/cli/utils.ts
+function getEslintConfigContent(mainConfig, additionalConfigs) {
+	return `
+import isentinel from '@isentinel/eslint-config'
+
+export default isentinel({
+${mainConfig}
+}${additionalConfigs?.map((config) => `,{\n${config}\n}`).join(",") ?? ""})
+`.trimStart();
+}
+function isGitClean() {
+	try {
+		execSync("git diff-index --quiet HEAD --");
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/cli/stages/update-eslint-files.ts
+const LEGACY_CONFIG_REGEX = /eslint|prettier/;
+async function updateEslintFiles(result) {
+	const cwd = process.cwd();
+	const pathESLintIgnore = path.join(cwd, ".eslintignore");
+	const pathPackageJSON = path.join(cwd, "package.json");
+	const packageContent = await fsp.readFile(pathPackageJSON, "utf-8");
+	const configFileName = JSON.parse(packageContent)["type"] === "module" ? "eslint.config.js" : "eslint.config.mjs";
+	const pathFlatConfig = path.join(cwd, configFileName);
+	const eslintIgnores = [];
+	if (fs.existsSync(pathESLintIgnore)) {
+		log.step(ansis.cyan("Migrating existing .eslintignore"));
+		const globs = index_default(await fsp.readFile(pathESLintIgnore, "utf-8")).globs();
+		for (const glob of globs) if (glob.type === "ignore") eslintIgnores.push(...glob.patterns);
+		else eslintIgnores.push(...glob.patterns.map((pattern) => `!${pattern}`));
+	}
+	const configLines = [];
+	if (eslintIgnores.length) configLines.push(`ignores: ${JSON.stringify(eslintIgnores)},`);
+	for (const framework of result.frameworks) configLines.push(`${framework}: true,`);
+	const eslintConfigContent = getEslintConfigContent(configLines.map((index) => `  ${index}`).join("\n"), []);
+	await fsp.writeFile(pathFlatConfig, eslintConfigContent);
+	log.success(ansis.green(`Created ${configFileName}`));
+	const files = fs.readdirSync(cwd);
+	const legacyConfig = [];
+	for (const file of files) if (LEGACY_CONFIG_REGEX.test(file) && !file.includes("eslint.config.")) legacyConfig.push(file);
+	if (legacyConfig.length) note(ansis.dim(legacyConfig.join(", ")), "You can now remove those files manually");
+}
+//#endregion
+//#region src/cli/constants-generated.ts
+const versionsMap = {
+	"eslint": "10.7.0",
+	"eslint-plugin-jest": "29.15.4",
+	"eslint-plugin-react-jsx": "5.17.2",
+	"eslint-plugin-react-naming-convention": "5.17.2",
+	"eslint-plugin-react-x": "5.17.2"
+};
+//#endregion
+//#region src/cli/stages/update-package-json.ts
+/** Scripts the wizard wires up so `pnpm lint` drives the hybrid runner. */
+const LINT_SCRIPTS = {
+	"lint": "isentinel-lint",
+	"lint:fix": "isentinel-lint --fix"
+};
+/**
+* Merge the lint scripts into a `scripts` block in place. Missing scripts are
+* always added. An existing script with identical content is left untouched. An
+* existing script with different content is preserved in skip-prompt mode, and
+* otherwise only overwritten when {@link ConfirmOverwrite} resolves true.
+*
+* @param scripts - The consumer's `scripts` block, mutated in place.
+* @param options - Skip-prompt flag and the overwrite confirmation callback.
+* @returns Which scripts were added and which were overwritten.
+*/
+async function mergeLintScripts(scripts, options) {
+	const added = [];
+	const overwritten = [];
+	for (const [name, desired] of Object.entries(LINT_SCRIPTS)) {
+		const existing = scripts[name];
+		if (existing === void 0) {
+			scripts[name] = desired;
+			added.push(name);
+			continue;
+		}
+		if (existing === desired || options.skipPrompt) continue;
+		if (await options.confirmOverwrite?.(name, existing, desired) === true) {
+			scripts[name] = desired;
+			overwritten.push(name);
+		}
+	}
+	return {
+		added,
+		overwritten
+	};
+}
+async function updatePackageJson(result, skipPrompt = false) {
+	const cwd = process.cwd();
+	const pathPackageJSON = path.join(cwd, "package.json");
+	log.step(ansis.cyan(`Bumping @isentinel/eslint-config to v${version}`));
+	const packageContent = await fsp.readFile(pathPackageJSON, "utf-8");
+	const parsedPackage = JSON.parse(packageContent);
+	parsedPackage.devDependencies ??= {};
+	parsedPackage.devDependencies["@isentinel/eslint-config"] = `^${version}`;
+	parsedPackage.devDependencies["eslint"] ??= versionsMap.eslint;
+	const addedPackages = [];
+	for (const framework of result.frameworks) {
+		if (!(framework in dependenciesMap)) continue;
+		const dependencies = dependenciesMap[framework];
+		for (const dependency of dependencies) {
+			parsedPackage.devDependencies[dependency] = versionsMap[dependency];
+			addedPackages.push(dependency);
+		}
+	}
+	if (addedPackages.length) note(ansis.dim(addedPackages.join(", ")), "Added packages");
+	parsedPackage.scripts ??= {};
+	const { scripts = {} } = parsedPackage;
+	const { added, overwritten } = await mergeLintScripts(scripts, {
+		confirmOverwrite: async (name, existing, desired) => {
+			return await confirm({
+				initialValue: false,
+				message: `A "${name}" script already exists ("${existing}"). Overwrite it with "${desired}"?`
+			}) === true;
+		},
+		skipPrompt
+	});
+	const touched = [...added, ...overwritten];
+	if (touched.length) note(ansis.dim(touched.map((name) => `${name}: ${scripts[name]}`).join("\n")), "Lint scripts");
+	await fsp.writeFile(pathPackageJSON, JSON.stringify(parsedPackage, null, 2));
+	log.success(ansis.green("Changes wrote to package.json"));
+}
+//#endregion
+//#region src/cli/stages/update-vscode-settings.ts
+async function updateVscodeSettings(result) {
+	if (!result.updateVscodeSettings) return;
+	const cwd = process.cwd();
+	const dotVscodePath = path.join(cwd, ".vscode");
+	const settingsPath = path.join(dotVscodePath, "settings.json");
+	if (!fs.existsSync(dotVscodePath)) await fsp.mkdir(dotVscodePath, { recursive: true });
+	if (!fs.existsSync(settingsPath)) {
+		await fsp.writeFile(settingsPath, `{${vscodeSettingsString}}\n`, "utf-8");
+		log.success(ansis.green("Created .vscode/settings.json"));
+		return;
+	}
+	let settingsContent = await fsp.readFile(settingsPath, "utf8");
+	settingsContent = settingsContent.trim();
+	if (settingsContent.endsWith("}")) settingsContent = settingsContent.slice(0, -1).trimEnd();
+	settingsContent += settingsContent.endsWith(",") || settingsContent.endsWith("{") ? "" : ",";
+	settingsContent += `${vscodeSettingsString}}\n`;
+	await fsp.writeFile(settingsPath, settingsContent, "utf-8");
+	log.success(ansis.green("Updated .vscode/settings.json"));
+}
+//#endregion
+//#region src/cli/run.ts
+async function run(options = {}) {
+	const argumentSkipPrompt = !!(process.env["SKIP_PROMPT"] ?? "") || options.yes;
+	const argumentTemplate = options.frameworks?.map((framework) => framework.trim()).filter((framework) => {
+		return frameworks.some((valid) => valid === framework);
+	});
+	const eslintConfigFiles = fs.readdirSync(process.cwd()).filter((file) => file.startsWith("eslint.config."));
+	if (eslintConfigFiles.length > 0) {
+		log.warn(ansis.yellow(`${eslintConfigFiles[0]} already exists, migration wizard exited.`));
+		return process.exit(1);
+	}
+	let result = {
+		frameworks: argumentTemplate ?? [],
+		uncommittedConfirmed: false,
+		updateVscodeSettings: true
+	};
+	if (argumentSkipPrompt !== true) {
+		const { frameworks: groupedFrameworks, uncommittedConfirmed, updateVscodeSettings: shouldUpdateVscode } = await group({
+			uncommittedConfirmed: async () => {
+				if (isGitClean()) return true;
+				return confirm({
+					initialValue: false,
+					message: "There are uncommitted changes in the current repository, are you sure to continue?"
+				});
+			},
+			frameworks: async ({ results }) => {
+				if ((argumentTemplate && argumentTemplate.length > 0 && argumentTemplate.every((template) => frameworks.includes(template))) === true || results.uncommittedConfirmed !== true) return;
+				const message = argumentTemplate && argumentTemplate.length > 0 ? `"${argumentTemplate.join(", ")}" isn't a valid template. Please choose from below: ` : "Select a framework:";
+				return multiselect({
+					message: ansis.reset(message),
+					options: frameworkOptions,
+					required: false
+				});
+			},
+			updateVscodeSettings: async ({ results }) => {
+				if (results.uncommittedConfirmed !== true) return;
+				return confirm({
+					initialValue: true,
+					message: "Update .vscode/settings.json for better VS Code experience?"
+				});
+			}
+		}, { onCancel: () => {
+			cancel("Operation cancelled.");
+			process.exit(0);
+		} });
+		result = {
+			frameworks: isStringArray(groupedFrameworks) ? groupedFrameworks.filter((value) => {
+				return frameworks.some((option) => option === value);
+			}) : [],
+			uncommittedConfirmed: uncommittedConfirmed === true,
+			updateVscodeSettings: shouldUpdateVscode !== false
+		};
+		if (!result.uncommittedConfirmed) return process.exit(1);
+	}
+	await updatePackageJson(result, argumentSkipPrompt === true);
+	await updateEslintFiles(result);
+	await updateVscodeSettings(result);
+	log.success(ansis.green("Setup completed"));
+	outro(`Now you can update the dependencies by running ${ansis.blue("pnpm install")} and lint by running ${ansis.blue("pnpm lint")} (or ${ansis.blue("pnpm lint:fix")})\n`);
+}
+//#endregion
+//#region src/cli/index.ts
+function header() {
+	console.log("\n");
+	const introText = ansis.green("@isentinel/eslint-config");
+	const versionText = `v${package_default.version}`;
+	intro(introText + ansis.dim(versionText));
+}
+yargs(hideBin(process.argv)).scriptName("@isentinel/eslint-config").usage("").command("*", "Run the initialization or migration", (args) => {
+	return args.option("yes", {
+		alias: "y",
+		description: "Skip prompts and use default values",
+		type: "boolean"
+	}).option("template", {
+		alias: "t",
+		description: "Use the framework template for optimal customization: react, jest",
+		type: "string"
+	}).help();
+}, async (args) => {
+	header();
+	try {
+		await run({
+			...args,
+			frameworks: args.template !== void 0 ? [args.template] : void 0
+		});
+	} catch (err) {
+		log.error(ansis.inverse(ansis.red(" Failed to migrate ")));
+		log.error(ansis.red(`✘ ${String(err)}`));
+		process.exit(1);
+	}
+}).showHelpOnFail(false).alias("h", "help").version("version", package_default.version).alias("v", "version").help().argv;
+//#endregion
 export {};