modern-cmdk-codemod 0.0.0-stage → 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,442 @@
+#!/usr/bin/env node
+import { i as findDirtyFiles, n as transformFile, r as discoverFiles, t as createApiFactory } from "./chunk-worker.mjs";
+import { findPackageJSON } from "node:module";
+import { readFile, writeFile } from "node:fs/promises";
+import { availableParallelism } from "node:os";
+import { relative } from "node:path";
+import { diff, parseArgs, styleText } from "node:util";
+import { Worker } from "node:worker_threads";
+// src/diff.ts
+/** Marks a final line that has no newline; stripped again when the hunk is printed. */
+const NO_EOL = "\0";
+const CONTEXT = 3;
+/** Split on LF or CRLF; a trailing newline adds no empty last line. */
+function toLines(text) {
+	if (text === "") return [];
+	const lines = text.split(/\r?\n/);
+	const last = lines.pop();
+	if (last !== "") lines.push(last + NO_EOL);
+	return lines;
+}
+function range(start, count) {
+	const first = count === 0 ? start - 1 : start;
+	return count === 1 ? `${first}` : `${first},${count}`;
+}
+function printRow([op, text]) {
+	return text.endsWith(NO_EOL) ? [`${op}${text.slice(0, -1)}`, "\"] : [`${op}${text}`];
+}
+/**
+* A unified diff of `before` against `after` for one file: `--- a/<path>`, `+++ b/<path>`, then
+* `@@` hunks with 3 lines of context. Returns '' when the two are equal line for line.
+*/
+function unifiedDiff(path, before, after) {
+	const rows = diff(toLines(before), toLines(after)).map(([op, text]) => [op === 0 ? " " : op === 1 ? "-" : "+", text]);
+	const changes = rows.flatMap(([op], index) => op === " " ? [] : [index]);
+	if (changes.length === 0) return "";
+	const groups = [];
+	for (const index of changes) {
+		const group = groups.at(-1);
+		if (group !== void 0 && index - group[1] - 1 <= 6) group[1] = index;
+		else groups.push([index, index]);
+	}
+	const out = [`--- a/${path}`, `+++ b/${path}`];
+	for (const [firstChange, lastChange] of groups) {
+		const start = Math.max(0, firstChange - CONTEXT);
+		const slice = rows.slice(start, Math.min(rows.length, lastChange + CONTEXT + 1));
+		const head = rows.slice(0, start);
+		const oldStart = head.filter(([op]) => op !== "+").length + 1;
+		const newStart = head.filter(([op]) => op !== "-").length + 1;
+		const oldCount = slice.filter(([op]) => op !== "+").length;
+		const newCount = slice.filter(([op]) => op !== "-").length;
+		out.push(`@@ -${range(oldStart, oldCount)} +${range(newStart, newCount)} @@`);
+		out.push(...slice.flatMap(printRow));
+	}
+	return out.join("\n");
+}
+// src/pool.ts
+/**
+* Run `task` over `items` with at most `concurrency` calls in flight.
+* Resolves, once every item has settled, to one `PromiseSettledResult` per item in input order.
+*/
+async function runPool(items, concurrency, task) {
+	const results = new Array(items.length);
+	const next = items.entries();
+	const runner = async () => {
+		for (const [index, item] of next) try {
+			results[index] = {
+				status: "fulfilled",
+				value: await task(item, index)
+			};
+		} catch (reason) {
+			results[index] = {
+				status: "rejected",
+				reason
+			};
+		}
+	};
+	await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, runner));
+	return results;
+}
+// src/cli.ts
+const AVAILABLE_TRANSFORMS = /* @__PURE__ */ new Map([
+	["import-rewrite", "Rewrites cmdk imports to modern-cmdk/react"],
+	["data-attrs", "Converts [cmdk-*] selectors to [data-command-*]"],
+	["forward-ref", "Removes React.forwardRef wrappers (React 19)"],
+	["should-filter", "Converts shouldFilter prop to filter"]
+]);
+/**
+* Dynamically import a transform module by name.
+*/
+async function loadTransform(name) {
+	return await import(
+		/* @vite-ignore */
+		`./transforms/${name}.mjs`
+);
+}
+const NODE_FLOOR_LINES = {
+	"modern-cmdk": "Node >= 26.4.0 (the floor modern-cmdk's toolchain and create-modern-cmdk declare; modern-cmdk itself declares no engines)",
+	"modern-cmdk-codemod": "Node >= 26.4.0 (the engines.node of modern-cmdk-codemod)"
+};
+function usageText(stream, program) {
+	const bold = (s) => styleText("bold", s, { stream });
+	const opt = (s) => styleText("cyan", s.padEnd(17), { stream });
+	const profile = program === "modern-cmdk" ? ["modern-cmdk (this bin) is deprecated. It runs with --lenient unless --strict is given.", "Use: npx modern-cmdk-codemod <transform> <glob|dir>"] : ["modern-cmdk-codemod runs with --strict unless --lenient is given. A strict run without --dry-run", "refuses to write into a git tree with uncommitted changes (or outside a git tree) unless --force is given."];
+	return [
+		`${bold("Usage:")} ${program} <transform> <glob|dir> [options]`,
+		"",
+		...profile,
+		"",
+		bold("Transforms:"),
+		...AVAILABLE_TRANSFORMS.entries().map(([name, description]) => `  ${opt(name)}${description}`).toArray(),
+		"",
+		bold("Options:"),
+		`  ${opt("--dry-run")}List the files that would change; write nothing`,
+		`  ${opt("--strict")}Exit 2 on usage errors (incl. unknown options), 1 on file errors`,
+		`  ${opt("--concurrency=N")}Files processed at once (default: min(8, available cores))`,
+		`  ${opt("-h, --help")}Show this help`,
+		`  ${opt("--lenient")}Keep the lenient exit codes below (cannot be combined with --strict) and skip the clean-git-tree check (modern-cmdk-codemod only)`,
+		`  ${opt("--force")}Skip the clean-git-tree check (modern-cmdk-codemod only; modern-cmdk ignores it)`,
+		`  ${opt("-v, --version")}Print the package name and version`,
+		"",
+		bold("Exit codes:"),
+		"  strict   0 success (reports included); 1 a file errored, no file matched or the run failed;",
+		"           2 usage error (unknown or malformed option, unknown transform, missing argument,",
+		"           --strict with --lenient) or a refused dirty tree (modern-cmdk-codemod only)",
+		"  lenient  0 for --help, missing arguments, usage errors and per-file errors; 1 for an unknown",
+		"           transform, no matching files and an uncaught error",
+		"",
+		"Files run on worker threads when --concurrency is above 1; --concurrency=1 runs them on the main thread.",
+		"A directory argument covers its .ts .tsx .mts .cts .js .jsx .mjs .cjs .css .scss files (dot paths excluded).",
+		"--dry-run also prints a unified diff of every file that would change.",
+		"",
+		NODE_FLOOR_LINES[program],
+		""
+	].join("\n");
+}
+/** The name and version of the package this file ships in (the nearest package.json). */
+async function readPackage() {
+	const path = findPackageJSON(import.meta.url);
+	if (path === void 0) throw new Error("cannot find this package's package.json");
+	return JSON.parse(await readFile(path, "utf-8"));
+}
+const OPTIONS = {
+	help: {
+		type: "boolean",
+		short: "h"
+	},
+	version: {
+		type: "boolean",
+		short: "v"
+	},
+	strict: { type: "boolean" },
+	lenient: { type: "boolean" },
+	force: { type: "boolean" },
+	"dry-run": { type: "boolean" },
+	concurrency: { type: "string" }
+};
+function parse(argv, program) {
+	const terminator = argv.indexOf("--");
+	const head = terminator === -1 ? argv : argv.slice(0, terminator);
+	if (head.includes("--strict") && head.includes("--lenient")) return {
+		kind: "usage-error",
+		message: "--strict and --lenient cannot be combined",
+		strict: true
+	};
+	const codemodProfile = program === "modern-cmdk-codemod";
+	const strictArg = head.includes("--strict") || codemodProfile && !head.includes("--lenient");
+	let values;
+	let positionals;
+	let ignored = [];
+	try {
+		({values, positionals} = parseCli(argv));
+	} catch (err) {
+		if (err.code !== "ERR_PARSE_ARGS_UNKNOWN_OPTION") return {
+			kind: "usage-error",
+			message: err instanceof Error ? err.message : String(err),
+			strict: strictArg
+		};
+		const loose = parseArgs({
+			args: [...argv],
+			options: OPTIONS,
+			allowPositionals: true,
+			strict: false,
+			tokens: true
+		});
+		ignored = loose.tokens.filter((t) => t.kind === "option" && !Object.hasOwn(OPTIONS, t.name)).map((t) => t.rawName);
+		const badValue = loose.tokens.find((t) => t.kind === "option" && Object.hasOwn(OPTIONS, t.name) && (OPTIONS[t.name].type === "boolean" ? t.value !== void 0 : t.value === void 0 || !t.inlineValue && t.value.length > 1 && t.value.startsWith("-")));
+		const badMessage = badValue?.kind === "option" ? badValue.value === void 0 ? `Option '${badValue.rawName} <value>' argument missing` : OPTIONS[badValue.name].type === "boolean" ? `Option '${badValue.rawName}' does not take an argument` : `Option '${badValue.rawName}' argument is ambiguous.\nDid you forget to specify the option argument for '${badValue.rawName}'?\nTo specify an option argument starting with a dash use '${badValue.rawName}=-XYZ'.` : void 0;
+		if (badMessage !== void 0) return {
+			kind: "usage-error",
+			message: badMessage,
+			strict: strictArg
+		};
+		if (strictArg || loose.values.help === true || loose.values.version === true || loose.positionals.length < 2) return {
+			kind: "usage-error",
+			message: `unknown option ${ignored[0]}`,
+			strict: strictArg
+		};
+		values = loose.values;
+		positionals = loose.positionals;
+	}
+	const strict = values.strict === true || values.lenient !== true && codemodProfile;
+	if (values.help) return { kind: "help" };
+	if (values.version) return { kind: "version" };
+	if (positionals.length < 2) return {
+		kind: "usage-error",
+		message: void 0,
+		strict
+	};
+	if (strict && positionals.length > 2) return {
+		kind: "usage-error",
+		message: `unexpected argument "${positionals[2]}" (quote the glob so the shell does not expand it)`,
+		strict
+	};
+	let concurrency = defaultConcurrency();
+	if (values.concurrency !== void 0) {
+		if (typeof values.concurrency !== "string" || !/^[1-9]\d*$/.test(values.concurrency)) return {
+			kind: "usage-error",
+			message: `--concurrency must be a positive integer, got "${String(values.concurrency)}"`,
+			strict
+		};
+		concurrency = Number.parseInt(values.concurrency, 10);
+	}
+	return {
+		kind: "run",
+		transformName: positionals[0],
+		fileGlob: positionals[1],
+		dryRun: values["dry-run"] === true,
+		force: values.force === true,
+		strict,
+		concurrency,
+		ignored
+	};
+}
+/** The default for --concurrency: one file per core, at most 8. */
+function defaultConcurrency(cores = availableParallelism()) {
+	return Math.min(8, cores);
+}
+function parseCli(argv) {
+	return parseArgs({
+		args: [...argv],
+		options: OPTIONS,
+		allowPositionals: true,
+		strict: true
+	});
+}
+/** Write a changed file (or build its dry-run diff) on the main thread and fold the outcome into a result. */
+async function finish(outcome, dryRun, rel) {
+	const { path: filePath, reports } = outcome;
+	if (outcome.error !== void 0) return {
+		filePath,
+		status: "error",
+		reports,
+		error: new Error(outcome.error)
+	};
+	if (outcome.skipped) return {
+		filePath,
+		status: "skipped",
+		reports
+	};
+	if (!outcome.changed) return {
+		filePath,
+		status: "unchanged",
+		reports
+	};
+	try {
+		const output = outcome.output;
+		if (!dryRun) await writeFile(filePath, output, "utf-8");
+		return {
+			filePath,
+			status: "changed",
+			...dryRun ? { diff: unifiedDiff(rel(filePath), outcome.source, output) } : {},
+			reports
+		};
+	} catch (err) {
+		return {
+			filePath,
+			status: "error",
+			reports,
+			error: err instanceof Error ? err : new Error(String(err))
+		};
+	}
+}
+/** Start `size` worker threads for `transform`; the transformer hands each file to an idle one. */
+function startWorkers(transform, keepSource, size) {
+	const init = {
+		kind: "modern-cmdk-codemod-worker",
+		transform,
+		keepSource
+	};
+	const slots = Array.from({ length: size }, () => ({ worker: new Worker(new URL("./worker.mjs", import.meta.url), { workerData: init }) }));
+	const pending = /* @__PURE__ */ new Map();
+	for (const slot of slots) {
+		const fail = (error) => {
+			slot.dead ??= error;
+			pending.get(slot)?.reject(slot.dead);
+		};
+		slot.worker.on("message", (outcome) => pending.get(slot)?.resolve(outcome));
+		slot.worker.on("error", fail);
+		slot.worker.on("exit", (code) => fail(/* @__PURE__ */ new Error(`worker thread exited with code ${code}`)));
+	}
+	const idle = [...slots];
+	const transformer = async (filePath) => {
+		const slot = idle.pop();
+		try {
+			if (slot.dead !== void 0) throw slot.dead;
+			const request = Promise.withResolvers();
+			pending.set(slot, request);
+			slot.worker.postMessage(filePath);
+			return await request.promise;
+		} finally {
+			pending.delete(slot);
+			idle.push(slot);
+		}
+	};
+	return {
+		transformer,
+		close: async () => {
+			await Promise.all(slots.map((slot) => slot.worker.terminate()));
+		}
+	};
+}
+/** The message for a refused dirty-tree run: up to 10 paths, the count, and the way out. */
+function dirtyMessage(paths, rel) {
+	const shown = paths.slice(0, 10).map((p) => `  ${rel(p)}`);
+	const more = paths.length > shown.length ? [`  ... and ${paths.length - shown.length} more`] : [];
+	return [
+		`refusing to write: ${paths.length} matched file${paths.length === 1 ? " has" : "s have"} uncommitted changes:`,
+		...shown,
+		...more,
+		"Commit or stash them, or pass --force to write anyway (--dry-run previews without writing)."
+	].join("\n");
+}
+/**
+* Run the codemod CLI. Resolves to the process exit code; writes only to `io`.
+*/
+async function run(argv, io, deps = {}) {
+	const out = (s) => void io.stdout.write(`${s}\n`);
+	const err = (s) => void io.stderr.write(`${s}\n`);
+	const fail = (s) => err(`${styleText("red", "error:", { stream: io.stderr })} ${s}`);
+	try {
+		const pkg = deps.program === void 0 ? await readPackage() : void 0;
+		const program = deps.program ?? (pkg?.name === "modern-cmdk" ? "modern-cmdk" : "modern-cmdk-codemod");
+		const parsed = parse(argv, program);
+		if (parsed.kind === "help") {
+			out(usageText(io.stdout, program));
+			return 0;
+		}
+		if (parsed.kind === "version") {
+			const { name, version } = pkg ?? await readPackage();
+			out(`${name} ${version}`);
+			return 0;
+		}
+		if (parsed.kind === "usage-error") {
+			if (parsed.message !== void 0) fail(parsed.message);
+			err(usageText(io.stderr, program));
+			return parsed.strict ? 2 : 0;
+		}
+		const { transformName, fileGlob, dryRun, force, strict, concurrency, ignored } = parsed;
+		for (const name of ignored) err(`warning: unknown option ${name} ignored (--strict makes this exit 2)`);
+		if (!AVAILABLE_TRANSFORMS.has(transformName)) {
+			fail(`unknown transform "${transformName}". Valid transforms: ${[...AVAILABLE_TRANSFORMS.keys()].join(", ")}`);
+			return strict ? 2 : 1;
+		}
+		const cwd = process.cwd();
+		const files = await discoverFiles([fileGlob], {
+			program,
+			cwd,
+			warn: err
+		});
+		if (files.length === 0) {
+			fail(`no files matched "${fileGlob}"`);
+			return 1;
+		}
+		const rel = (p) => relative(cwd, p).replaceAll("\\", "/");
+		if (program === "modern-cmdk-codemod" && strict && !dryRun && !force) {
+			const dirty = await findDirtyFiles(files, cwd);
+			if (dirty.kind === "outside") {
+				const n = dirty.paths.length;
+				const shown = dirty.paths.slice(0, 10).map((p) => `  ${rel(p)}`);
+				fail([
+					`refusing to write: ${n} matched file${n === 1 ? " lies" : "s lie"} outside this git work tree:`,
+					...shown,
+					...n > shown.length ? [`  ... and ${n - shown.length} more`] : [],
+					"Run the codemod from that tree, or pass --force to write anyway."
+				].join("\n"));
+				return 2;
+			}
+			if (dirty.kind === "dirty") {
+				fail(dirtyMessage(dirty.paths, rel));
+				return 2;
+			}
+			if (dirty.kind !== "clean") {
+				fail(dirty.kind === "no-git" ? "refusing to write: git not found, so a clean tree cannot be confirmed. Pass --force to write anyway." : "refusing to write outside a git work tree: nothing could undo it. Pass --force to write anyway.");
+				return 2;
+			}
+		}
+		const mod = await (deps.loadTransform ?? loadTransform)(transformName);
+		let transformer;
+		let closeWorkers = async () => {};
+		if (concurrency > 1 && deps.loadTransform === void 0) ({transformer, close: closeWorkers} = startWorkers(transformName, dryRun, Math.min(concurrency, files.length)));
+		else {
+			const apiForParser = createApiFactory();
+			transformer = (filePath) => transformFile(filePath, mod, apiForParser, dryRun);
+		}
+		let settled;
+		try {
+			settled = await runPool(files, concurrency, async (filePath) => finish(await transformer(filePath), dryRun, rel));
+		} finally {
+			await closeWorkers();
+		}
+		const results = settled.map((r, i) => r.status === "fulfilled" ? r.value : {
+			filePath: files[i],
+			status: "error",
+			reports: [],
+			error: r.reason instanceof Error ? r.reason : new Error(String(r.reason))
+		});
+		const counts = {
+			changed: 0,
+			unchanged: 0,
+			skipped: 0,
+			error: 0,
+			reported: 0
+		};
+		for (const r of results) {
+			counts[r.status]++;
+			counts.reported += r.reports.length;
+			for (const message of r.reports) err(`${rel(r.filePath)}: ${message}`);
+			if (r.error) err(`${rel(r.filePath)}: ${r.error.message}`);
+			else if (r.status === "changed") {
+				out(`${styleText("green", dryRun ? "would change" : "changed", { stream: io.stdout })} ${rel(r.filePath)}`);
+				if (r.diff) out(r.diff);
+			}
+		}
+		out(`${counts.changed} changed, ${counts.unchanged} unchanged, ${counts.error} errors` + (counts.skipped > 0 ? `, ${counts.skipped} skipped` : "") + (counts.reported > 0 ? `, ${counts.reported} reported` : "") + (dryRun ? " (dry run, nothing written)" : ""));
+		return strict && counts.error > 0 ? 1 : 0;
+	} catch (e) {
+		fail(e instanceof Error ? e.message : String(e));
+		return 1;
+	}
+}
+if (import.meta.main) process.exitCode = await run(process.argv.slice(2), process);
+export { defaultConcurrency, run };