migrate-to-comark 0.0.0 → 0.9.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 onmax
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,24 @@
 # migrate-to-comark
 
-Placeholder. Finds the Markdown libraries a project uses and moves it to Comark. The first release is coming soon: https://comark-ui.onmax.me/migrate-to-comark
+[![npm version](https://comark-ui.onmax.me/badge.svg?source=npm-version&package=migrate-to-comark&icon=npm)](https://npmx.dev/package/migrate-to-comark)
+[![license](https://comark-ui.onmax.me/badge.svg?label=license&value=MIT)](https://npmx.dev/package/migrate-to-comark)
+[![docs](https://comark-ui.onmax.me/badge.svg?label=docs&value=comark-ui.onmax.me)](https://comark-ui.onmax.me/migrate-to-comark/)
+
+A wizard that moves a project to [Comark](https://comark.dev). It reads every package.json, finds remark, markdown-it, or marked, runs the migrator for each, and asks before writing what they would write.
+
+```sh
+npx migrate-to-comark            # asks before writing
+npx migrate-to-comark --dry-run  # reports only
+npx migrate-to-comark --yes      # writes without asking
+npx migrate-to-comark --json     # for agents
+```
+
+| Library | Migrator |
+| --- | --- |
+| remark, unified, react-markdown, MDX, Astro, Docusaurus | [remark-to-comark](https://comark-ui.onmax.me/remark-to-comark/) |
+| markdown-it, VitePress, VuePress, Eleventy | [markdown-it-to-comark](https://comark-ui.onmax.me/markdown-it-to-comark/) |
+| marked | [marked-to-comark](https://comark-ui.onmax.me/marked-to-comark/) |
+
+A file two migrators both want goes to the library its nearest package.json declares; if that doesn't settle it, the wizard leaves the file alone. It also skips any file that changed after the check read it, and keeps the code that renders Markdown on its library until every Markdown file it renders is migrated. Each migrator's `check --verbose` lists what's left to do, with a fix for each finding.
+
+See the [docs](https://comark-ui.onmax.me/migrate-to-comark/).

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/cli.mjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+import { n as load, r as plan, t as apply } from "./migrate-B1Q-GmiU.mjs";
+import { existsSync, statSync } from "node:fs";
+import { parseArgs } from "node:util";
+import * as prompts from "@clack/prompts";
+//#region src/summary.ts
+const NAMES = {
+	remark: "remark",
+	"markdown-it": "markdown-it",
+	marked: "marked"
+};
+/** Where the project declares a library, in one line: the first few dependencies and their package.json files. */
+function declared(report) {
+	const { uses } = report.detection;
+	const names = [...new Set(uses.map((use) => use.dependency))];
+	const manifests = [...new Set(uses.map((use) => use.manifest))];
+	return `${names.slice(0, 4).join(", ")}${names.length > 4 ? `, and ${names.length - 4} more` : ""} in ${manifests.length === 1 ? manifests[0] : `${manifests.length} package.json files`}`;
+}
+/** Each migrator's result as plain lines: what it can change, then each kind of warning it leaves, with its docs. */
+async function describe(plan, load) {
+	const lines = [];
+	for (const report of plan.reports) {
+		const { library, migrator } = report.detection;
+		if (!report.findings) {
+			lines.push(`${NAMES[library]}: ${migrator} couldn't run (${report.error}). Run \`npx ${migrator} check .\` to see why.`);
+			continue;
+		}
+		const module = await load(migrator);
+		const changes = plan.changes.filter((change) => change.migrator === migrator);
+		const warnings = report.findings.filter((finding) => module.catalog[finding.code]?.severity === "warn" && !finding.edit);
+		lines.push(`${NAMES[library]} (${declared(report)}): ${counted(changes)}, ${warnings.length} ${warnings.length === 1 ? "warning" : "warnings"} left to you.`);
+		const byCode = /* @__PURE__ */ new Map();
+		for (const finding of warnings) byCode.set(finding.code, (byCode.get(finding.code) ?? 0) + 1);
+		for (const [code, count] of [...byCode].sort((a, b) => b[1] - a[1])) {
+			const first = warnings.find((finding) => finding.code === code);
+			const { docs } = module.toDiagnostic(first);
+			lines.push(`  ${count} × ${code} ${module.catalog[code].ruleId}${docs ? ` (${docs})` : ""}`);
+		}
+	}
+	return lines;
+}
+/** "3 Markdown files and 1 code file to change", from the edits a migrator carries. */
+function counted(changes) {
+	const markdown = changes.filter((change) => /\.(md|mdx|markdown)$/i.test(change.file)).length;
+	const code = changes.length - markdown;
+	if (!changes.length) return "nothing to change automatically";
+	return `${[markdown && `${markdown} Markdown ${markdown === 1 ? "file" : "files"}`, code && `${code} code ${code === 1 ? "file" : "files"}`].filter(Boolean).join(" and ")} to change`;
+}
+//#endregion
+//#region src/cli.ts
+const USAGE = `Usage:
+  migrate-to-comark [dir]             find the project's Markdown libraries and move it to Comark, asking first
+  migrate-to-comark [dir] --dry-run   report what would change, and write nothing
+  migrate-to-comark [dir] --yes       write every change without asking
+  migrate-to-comark [dir] --json      the report as JSON, for agents (add --yes to write)
+  migrate-to-comark [dir] --only markdown-it   move only this library (remark, markdown-it, or marked; repeatable)`;
+const { positionals, values } = parseArgs({
+	allowPositionals: true,
+	options: {
+		yes: {
+			type: "boolean",
+			default: false
+		},
+		"dry-run": {
+			type: "boolean",
+			default: false
+		},
+		json: {
+			type: "boolean",
+			default: false
+		},
+		only: {
+			type: "string",
+			multiple: true
+		},
+		help: {
+			type: "boolean",
+			short: "h",
+			default: false
+		}
+	}
+});
+if (values.help || positionals.length > 1) {
+	console.log(USAGE);
+	process.exit(values.help ? 0 : 1);
+}
+const root = positionals[0] ?? ".";
+if (!existsSync(root) || !statSync(root).isDirectory()) {
+	console.error(`Cannot migrate \`${root}\`: no such directory.`);
+	process.exit(1);
+}
+const LIBRARIES = [
+	"remark",
+	"markdown-it",
+	"marked"
+];
+const unknown = values.only?.find((library) => !LIBRARIES.includes(library));
+if (unknown) {
+	console.error(`Cannot move \`${unknown}\`: --only takes ${LIBRARIES.join(", ")}.`);
+	process.exit(1);
+}
+const only = values.only?.length ? values.only : void 0;
+const interactive = process.stdin.isTTY && process.stdout.isTTY && !values.yes && !values["dry-run"] && !values.json;
+if (values.json) await json();
+else if (interactive) await wizard();
+else await report();
+async function wizard() {
+	prompts.intro("migrate-to-comark");
+	const first = await plan(root, {
+		only: [],
+		load
+	});
+	if (!found(first.detected, (line) => prompts.log.warn(line))) {
+		prompts.outro("Nothing to migrate.");
+		return;
+	}
+	for (const detection of first.detected.libraries) prompts.log.info(`Found ${detection.library}, moved by ${detection.migrator}.`);
+	let picked = first.detected.libraries.map((detection) => detection.library).filter((library) => !only || only.includes(library));
+	if (!only && picked.length > 1) {
+		const chosen = await prompts.multiselect({
+			message: "Which libraries do you want to move to Comark?",
+			options: picked.map((library) => ({
+				value: library,
+				label: library
+			})),
+			initialValues: picked
+		});
+		if (prompts.isCancel(chosen)) return prompts.cancel("Nothing written.");
+		picked = chosen;
+	}
+	const spinner = prompts.spinner();
+	spinner.start("Checking the project");
+	const result = await plan(root, {
+		only: picked,
+		load
+	});
+	spinner.stop("Checked the project");
+	prompts.note((await describe(result, load)).join("\n"), "What each migrator found");
+	for (const conflict of result.conflicts) prompts.log.warn(`${conflict.file} is left as it is: ${conflict.migrators.join(" and ")} would both change it. Run each one's \`content\` command on it and keep the result that renders right.`);
+	for (const entry of result.held) prompts.log.warn(heldBack(entry));
+	if (!result.changes.length) {
+		prompts.outro(next(result));
+		return;
+	}
+	const go = await prompts.confirm({ message: `Write ${result.changes.length} ${result.changes.length === 1 ? "file" : "files"}?` });
+	if (prompts.isCancel(go) || !go) return prompts.cancel("Nothing written.");
+	const { written, stale, held } = apply(root, result.changes);
+	prompts.log.success(`Wrote ${written.length} ${written.length === 1 ? "file" : "files"}.`);
+	for (const file of stale) prompts.log.warn(`${file} changed while the wizard ran, so it was left as it is. Run the wizard again.`);
+	for (const entry of held) prompts.log.warn(heldBack(entry));
+	prompts.outro(next(result));
+}
+async function report() {
+	const result = await plan(root, {
+		only,
+		load
+	});
+	if (!found(result.detected, (line) => console.log(line))) return;
+	console.log((await describe(result, load)).join("\n"));
+	for (const conflict of result.conflicts) console.log(`${conflict.file} is left as it is: ${conflict.migrators.join(" and ")} would both change it.`);
+	for (const entry of result.held) console.log(heldBack(entry));
+	if (values.yes) {
+		const { written, stale, held } = apply(root, result.changes);
+		console.log(`\nWrote ${written.length} ${written.length === 1 ? "file" : "files"}.`);
+		for (const file of stale) console.log(`${file} changed while the wizard ran; left as it is.`);
+		for (const entry of held) console.log(heldBack(entry));
+	} else if (result.changes.length) console.log(`\nNothing written. Run again with --yes to write ${result.changes.length} ${result.changes.length === 1 ? "file" : "files"}.`);
+	console.log(`\n${next(result)}`);
+}
+async function json() {
+	const result = await plan(root, {
+		only,
+		load
+	});
+	const applied = values.yes ? apply(root, result.changes) : void 0;
+	console.log(JSON.stringify({
+		libraries: result.detected.libraries,
+		unsupported: result.detected.unsupported,
+		comark: result.detected.comark,
+		reports: result.reports.map(({ detection, findings, error }) => ({
+			library: detection.library,
+			migrator: detection.migrator,
+			findings: findings?.length,
+			error
+		})),
+		changes: result.changes.map(({ file, migrator }) => ({
+			file,
+			migrator
+		})),
+		conflicts: result.conflicts,
+		held: [...result.held, ...applied?.held ?? []],
+		written: applied?.written,
+		stale: applied?.stale
+	}, null, 2));
+}
+/** Says what was found; false when there's nothing any migrator moves. */
+function found(detected, say) {
+	for (const { name, uses } of detected.unsupported) say(`${name} (${uses[0].manifest}) has no migrator yet, so its Markdown stays as it is.`);
+	if (detected.libraries.length) return true;
+	say(`No package.json under ${root} declares remark, markdown-it, or marked${detected.comark ? ", and comark is already a dependency" : ""}.`);
+	return false;
+}
+/** Why a setup file still uses its library, and which Markdown files it waits on. */
+function heldBack({ file, migrator, waiting }) {
+	return `${file} still renders with ${migrator.replace(/-to-comark$/, "")}: switching it now would change how ${`${waiting.slice(0, 3).join(", ")}${waiting.length > 3 ? `, and ${waiting.length - 3} more` : ""}`} ${waiting.length === 1 ? "renders" : "render"}. Migrate ${waiting.length === 1 ? "it" : "them"} first (\`npx ${migrator} check ${JSON.stringify(root)} --verbose\` says how), then run the wizard again.`;
+}
+/** The commands that show what's left, one per migrator that ran. */
+function next(result) {
+	return ["Review the changes with `git diff`. Every finding, with its fix:", ...result.reports.map(({ detection }) => `npx ${detection.migrator} check ${JSON.stringify(root)} --verbose`).map((command) => `  ${command}`)].join("\n");
+}
+//#endregion
+export {};

package/dist/index.d.mts

@@ -0,0 +1,112 @@
+//#region src/detect.d.ts
+type Library = "remark" | "markdown-it" | "marked";
+/** A Markdown library the project declares, and every package.json dependency that brought it in. */
+interface Detection {
+  library: Library;
+  /** The npm package that moves this library's projects to Comark. */
+  migrator: string;
+  uses: Use[];
+}
+/** A Markdown library with no migrator, so the wizard can say so instead of staying silent. */
+interface Unsupported {
+  name: string;
+  uses: Use[];
+}
+interface Use {
+  /** The package.json that declares it, relative to the root. */
+  manifest: string;
+  dependency: string;
+  version: string;
+}
+interface Detected {
+  libraries: Detection[];
+  unsupported: Unsupported[];
+  /** Whether a package.json already declares comark. */
+  comark: boolean;
+}
+/** The Markdown libraries every package.json under `root` declares, skipping installed and built files. */
+export declare function detect(root: string): Promise<Detected>;
+//#endregion
+//#region src/migrate.d.ts
+/** What every migrator's check reports, the shape remark-to-comark set. */
+interface Finding {
+  code: string;
+  params: Record<string, unknown> & {
+    at: string;
+  };
+  file: string;
+  line: number;
+  edit?: {
+    source: string;
+    start: number;
+    end: number;
+    text: string;
+  };
+}
+/** The part of a migrator package the wizard drives. Each one exports these from its root. */
+interface Migrator {
+  check: (root: string) => Promise<Finding[]>;
+  catalog: Record<string, {
+    severity: "warn" | "info";
+    ruleId: string;
+  }>;
+  toDiagnostic: (finding: Finding) => {
+    why: string;
+    fix: string;
+    docs?: string;
+  };
+}
+interface Report {
+  detection: Detection;
+  /** Undefined when the migrator couldn't be loaded or threw; `error` says why. */
+  findings?: Finding[];
+  error?: string;
+}
+/** One file's change: the migrator that wants it and the edit, against the text the check read. */
+interface Change {
+  file: string;
+  migrator: string;
+  source: string;
+  edit: NonNullable<Finding["edit"]>;
+  /** A setup rewrite waits for these content files to be written by the same migrator. */
+  requires?: string[];
+}
+interface Plan {
+  detected: Detected;
+  reports: Report[];
+  changes: Change[];
+  /** Files more than one migrator wants to change, left as they are. */
+  conflicts: {
+    file: string;
+    migrators: string[];
+  }[];
+  /** Setup files left on their library, because switching them would change how these Markdown files render. */
+  held: Held[];
+}
+interface Held {
+  file: string;
+  migrator: string;
+  waiting: string[];
+}
+type Load = (migrator: string) => Promise<Migrator>;
+/** Imports a migrator package by name, from the wizard's own dependencies. */
+export declare const load: Load;
+/**
+ * Detects the project's Markdown libraries, runs the migrator of each one in `only` (all by default), and collects the
+ * edits their findings carry: the same ones each migrator's `rewrite --write` and `content --write` make.
+ */
+export declare function plan(root: string, options?: {
+  only?: string[];
+  load?: Load;
+}): Promise<Plan>;
+/**
+ * Writes content before dependent setup rewrites, unless a file changed since the check read it.
+ * A setup stays unchanged unless all its required content edits were written by that migrator.
+ */
+export declare function apply(root: string, changes: Change[]): {
+  written: string[];
+  stale: string[];
+  held: Held[];
+};
+//#endregion
+export type { Change, Detected, Detection, Finding, Held, Library, Load, Migrator, Plan, Report, Unsupported, Use };

package/dist/index.mjs

@@ -0,0 +1 @@
+export { t as apply, i as detect, n as load, r as plan } from "./migrate-B1Q-GmiU.mjs";

package/dist/migrate-B1Q-GmiU.mjs

@@ -0,0 +1,222 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { glob } from "tinyglobby";
+//#region src/detect.ts
+const LIBRARIES = [
+	{
+		library: "remark",
+		migrator: "remark-to-comark",
+		match: /^(unified|remark|remark-.+|rehype|rehype-.+|mdast-.+|react-markdown|streamdown|@mdx-js\/.+|astro|@astrojs\/(markdown-remark|mdx)|@docusaurus\/core|gatsby-transformer-remark|nextra|fumadocs-core|@nuxt\/content|contentlayer2?|velite)$/
+	},
+	{
+		library: "markdown-it",
+		migrator: "markdown-it-to-comark",
+		match: /^(markdown-it|markdown-it-.+|@mdit\/.+|@mdit-vue\/.+|vitepress|vuepress|@vuepress\/.+|@slidev\/cli|@11ty\/eleventy|hexo-renderer-markdown-it|@marp-team\/marp-core|vue-markdown-render)$/
+	},
+	{
+		library: "marked",
+		migrator: "marked-to-comark",
+		match: /^(marked|marked-.+|svelte-markdown|ngx-markdown)$/
+	}
+];
+const UNSUPPORTED = /* @__PURE__ */ new Set([
+	"showdown",
+	"@markdoc/markdoc",
+	"markdown-to-jsx",
+	"commonmark",
+	"snarkdown",
+	"markdown-wasm"
+]);
+const FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+/** The Markdown libraries every package.json under `root` declares, skipping installed and built files. */
+async function detect(root) {
+	const manifests = (await glob("**/package.json", {
+		cwd: root,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/.output/**",
+			"**/.nuxt/**",
+			"**/.next/**"
+		]
+	})).sort();
+	const found = /* @__PURE__ */ new Map();
+	const unsupported = /* @__PURE__ */ new Map();
+	let comark = false;
+	for (const manifest of manifests) {
+		let json;
+		try {
+			json = JSON.parse(readFileSync(join(root, manifest), "utf8"));
+		} catch {
+			continue;
+		}
+		for (const field of FIELDS) for (const [dependency, version] of Object.entries(json[field] ?? {})) {
+			const use = {
+				manifest,
+				dependency,
+				version: String(version)
+			};
+			if (dependency === "comark") comark = true;
+			if (UNSUPPORTED.has(dependency)) unsupported.set(dependency, [...unsupported.get(dependency) ?? [], use]);
+			for (const { library, match } of LIBRARIES) if (match.test(dependency)) found.set(library, [...found.get(library) ?? [], use]);
+		}
+	}
+	return {
+		libraries: LIBRARIES.flatMap(({ library, migrator }) => {
+			const uses = found.get(library);
+			return uses ? [{
+				library,
+				migrator,
+				uses
+			}] : [];
+		}),
+		unsupported: [...unsupported].map(([name, uses]) => ({
+			name,
+			uses
+		})),
+		comark
+	};
+}
+//#endregion
+//#region src/migrate.ts
+/** Imports a migrator package by name, from the wizard's own dependencies. */
+const load = async (migrator) => {
+	return await import(migrator);
+};
+/**
+* Detects the project's Markdown libraries, runs the migrator of each one in `only` (all by default), and collects the
+* edits their findings carry: the same ones each migrator's `rewrite --write` and `content --write` make.
+*/
+async function plan(root, options = {}) {
+	const detected = await detect(root);
+	const reports = [];
+	for (const detection of detected.libraries) {
+		if (options.only && !options.only.includes(detection.library)) continue;
+		try {
+			const migrator = await (options.load ?? load)(detection.migrator);
+			reports.push({
+				detection,
+				findings: await migrator.check(root)
+			});
+		} catch (error) {
+			reports.push({
+				detection,
+				error: String(error instanceof Error ? error.message : error).split("\n")[0]
+			});
+		}
+	}
+	const wanted = /* @__PURE__ */ new Map();
+	const held = [];
+	for (const { detection, findings } of reports) {
+		const unresolved = [...new Set(findings?.filter((finding) => finding.code.endsWith("0303") || finding.code.endsWith("0302") && !finding.edit).map((finding) => finding.file))];
+		const contentFiles = [...new Set(findings?.filter((finding) => finding.code.endsWith("0302")).map((finding) => finding.file))];
+		for (const finding of findings ?? []) {
+			if (!finding.edit) continue;
+			if (unresolved.length && finding.code.endsWith("0202")) {
+				if (!held.some((entry) => entry.file === finding.file && entry.migrator === detection.migrator)) held.push({
+					file: finding.file,
+					migrator: detection.migrator,
+					waiting: unresolved
+				});
+				continue;
+			}
+			const changes = wanted.get(finding.file) ?? [];
+			if (changes.some((change) => change.migrator === detection.migrator && same(change.edit, finding.edit))) continue;
+			changes.push({
+				file: finding.file,
+				migrator: detection.migrator,
+				source: finding.edit.source,
+				edit: finding.edit,
+				requires: finding.code.endsWith("0202") ? contentFiles : void 0
+			});
+			wanted.set(finding.file, changes);
+		}
+	}
+	const changes = [];
+	const conflicts = [];
+	for (const [file, list] of [...wanted].sort(([a], [b]) => a.localeCompare(b))) {
+		const owned = list.length === 1 ? list[0] : owner(file, list, detected);
+		if (owned) changes.push(owned);
+		else conflicts.push({
+			file,
+			migrators: [...new Set(list.map((change) => change.migrator))]
+		});
+	}
+	for (const change of changes.filter((change) => change.requires)) {
+		const waiting = change.requires.filter((file) => !changes.some((other) => other.file === file && other.migrator === change.migrator));
+		if (!waiting.length) continue;
+		changes.splice(changes.indexOf(change), 1);
+		held.push({
+			file: change.file,
+			migrator: change.migrator,
+			waiting
+		});
+	}
+	return {
+		detected,
+		reports,
+		changes,
+		conflicts,
+		held
+	};
+}
+/**
+* In a monorepo every migrator wants every Markdown file, so a file goes to the library its nearest declaring
+* package.json uses, such as a VitePress site's own package. A package.json that declares several of them decides
+* nothing.
+*/
+function owner(file, list, detected) {
+	const declared = /* @__PURE__ */ new Map();
+	for (const { migrator, uses } of detected.libraries) for (const { manifest } of uses) declared.set(manifest, /* @__PURE__ */ new Set([...declared.get(manifest) ?? [], migrator]));
+	for (let dir = dirname(file);; dir = dirname(dir)) {
+		const manifest = dir === "." ? "package.json" : `${dir}/package.json`;
+		const competing = list.filter((change) => declared.get(manifest)?.has(change.migrator));
+		if (competing.length) return competing.length === 1 ? competing[0] : void 0;
+		if (dir === "." || dir === dirname(dir)) return void 0;
+	}
+}
+const same = (a, b) => a.start === b.start && a.end === b.end && a.text === b.text;
+/**
+* Writes content before dependent setup rewrites, unless a file changed since the check read it.
+* A setup stays unchanged unless all its required content edits were written by that migrator.
+*/
+function apply(root, changes) {
+	const written = [];
+	const stale = [];
+	const held = [];
+	const applied = /* @__PURE__ */ new Map();
+	const ordered = [...changes.filter((change) => !change.requires), ...changes.filter((change) => change.requires)];
+	for (const { file, source, edit, migrator, requires } of ordered) {
+		const waiting = requires?.filter((required) => !applied.get(migrator)?.has(required));
+		if (waiting?.length) {
+			held.push({
+				file,
+				migrator,
+				waiting
+			});
+			continue;
+		}
+		const path = join(root, file);
+		if (readFileSync(path, "utf8") !== source) {
+			stale.push(file);
+			continue;
+		}
+		writeFileSync(path, source.slice(0, edit.start) + edit.text + source.slice(edit.end));
+		written.push(file);
+		const files = applied.get(migrator) ?? /* @__PURE__ */ new Set();
+		files.add(file);
+		applied.set(migrator, files);
+	}
+	return {
+		written,
+		stale,
+		held
+	};
+}
+//#endregion
+export { detect as i, load as n, plan as r, apply as t };

package/package.json

@@ -1,11 +1,61 @@
 {
   "name": "migrate-to-comark",
-  "version": "0.0.0",
-  "description": "Placeholder. Finds the Markdown libraries a project uses and moves it to Comark. The first release is coming soon.",
-  "keywords": ["codemod", "comark", "markdown", "migration", "wizard"],
+  "version": "0.9.0",
+  "description": "A wizard that finds the Markdown libraries a project uses (remark, markdown-it, marked) and moves it to Comark with each library's migrator.",
+  "keywords": [
+    "codemod",
+    "comark",
+    "markdown",
+    "markdown-it",
+    "marked",
+    "migration",
+    "remark",
+    "wizard"
+  ],
   "homepage": "https://comark-ui.onmax.me/migrate-to-comark",
   "bugs": "https://github.com/onmax/comark-ui/issues",
   "license": "MIT",
   "author": "onmax",
-  "repository": { "type": "git", "url": "git+https://github.com/onmax/comark-ui.git", "directory": "packages/migrate-to-comark" }
-}
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/onmax/comark-ui.git",
+    "directory": "packages/migrate-to-comark"
+  },
+  "bin": {
+    "migrate-to-comark": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.8.1",
+    "tinyglobby": "^0.2.17",
+    "marked-to-comark": "0.9.0",
+    "remark-to-comark": "0.9.0",
+    "markdown-it-to-comark": "0.9.0"
+  },
+  "devDependencies": {
+    "comark": "^0.8.1"
+  },
+  "peerDependencies": {
+    "comark": "^0.8.0"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "doctor": "vite-doctor . --no-cache --max-warnings 0 --format text"
+  }
+}