@rrlab/cli 1.0.1-git-908d2c0.0 → 1.1.1-git-4903a88.0

package/dist/plugin/__tests__/bin-probe.test.d.mts

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

package/dist/plugin/__tests__/bin-probe.test.mjs

@@ -0,0 +1,64 @@
+import { ToolService } from "../tool-service.mjs";
+import { probeBins } from "../bin-probe.mjs";
+import { i as it, r as describe, t as globalExpect } from "../../test.DNmyFkvJ-09ScyH13.mjs";
+//#region src/lib/plugin/__tests__/bin-probe.test.ts
+const FROM = import.meta.url;
+var ResolvableService = class extends ToolService {
+	constructor() {
+		super({
+			pkg: "typescript",
+			bin: "tsc",
+			color: (s) => s,
+			shellService: {},
+			from: FROM
+		});
+	}
+};
+var MissingService = class extends ToolService {
+	constructor() {
+		super({
+			bin: "ghostly-bin-that-does-not-exist",
+			color: (s) => s,
+			shellService: {},
+			from: FROM
+		});
+	}
+};
+var AlsoMissing = class extends ToolService {
+	constructor() {
+		super({
+			bin: "another-ghost-bin",
+			color: (s) => s,
+			shellService: {},
+			from: FROM
+		});
+	}
+};
+describe("probeBins", () => {
+	it("is a no-op when given an empty list", async () => {
+		await globalExpect(probeBins([], "noop")).resolves.toBeUndefined();
+	});
+	it("ignores non-ToolService values silently", async () => {
+		await globalExpect(probeBins([
+			{ random: "object" },
+			42,
+			null
+		], "noop")).resolves.toBeUndefined();
+	});
+	it("succeeds when every distinct pkg resolves", async () => {
+		await globalExpect(probeBins([new ResolvableService(), new ResolvableService()], "ts")).resolves.toBeUndefined();
+	});
+	it("throws with the canonical message listing the missing pkg", async () => {
+		await globalExpect(probeBins([new MissingService()], "ghostly")).rejects.toThrow(/@rrlab\/ghostly-plugin requires ghostly-bin-that-does-not-exist to be installed in the host project\. Run: rr plugins add ghostly {2}\(or: pnpm add -D ghostly-bin-that-does-not-exist\)/);
+	});
+	it("lists multiple distinct missing pkgs in the same error", async () => {
+		await globalExpect(probeBins([new MissingService(), new AlsoMissing()], "ghostly")).rejects.toThrow(/requires .*(ghostly-bin-that-does-not-exist|another-ghost-bin).*(another-ghost-bin|ghostly-bin-that-does-not-exist)/);
+	});
+	it("deduplicates services sharing a pkg into a single probe", async () => {
+		const err = await probeBins([new MissingService(), new MissingService()], "ghostly").catch((e) => e);
+		globalExpect(err).toBeInstanceOf(Error);
+		globalExpect(err.message.match(/ghostly-bin-that-does-not-exist/g)?.length).toBe(2);
+	});
+});
+//#endregion
+export {};

package/dist/plugin/__tests__/decide-scaffold.test.d.mts

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

package/dist/plugin/__tests__/decide-scaffold.test.mjs

@@ -0,0 +1,103 @@
+import { decideScaffold } from "../decide-scaffold.mjs";
+import { i as it, n as vi, r as describe, t as globalExpect } from "../../test.DNmyFkvJ-09ScyH13.mjs";
+//#region src/lib/plugin/__tests__/decide-scaffold.test.ts
+function makeCtx(overrides = {}) {
+	return {
+		shell: {},
+		logger: {},
+		appPkg: { dirPath: process.cwd() },
+		prompts: overrides.prompts ?? {},
+		flags: {
+			force: false,
+			yes: false,
+			nonInteractive: false,
+			...overrides.flags
+		},
+		release: {}
+	};
+}
+describe("decideScaffold", () => {
+	describe("unattended (--yes or non-interactive)", () => {
+		it("returns 'create' when file does not exist", async () => {
+			globalExpect(await decideScaffold(makeCtx({ flags: { yes: true } }), {
+				label: "biome.json",
+				fileExists: false,
+				patchHint: "x"
+			})).toBe("create");
+		});
+		it("returns 'patch' when file exists and default unattendedExistingAction", async () => {
+			globalExpect(await decideScaffold(makeCtx({ flags: { yes: true } }), {
+				label: "biome.json",
+				fileExists: true,
+				patchHint: "x"
+			})).toBe("patch");
+		});
+		it("returns 'skip' when file exists and unattendedExistingAction: 'skip'", async () => {
+			globalExpect(await decideScaffold(makeCtx({ flags: { nonInteractive: true } }), {
+				label: "tsdown.config.ts",
+				fileExists: true,
+				patchHint: "x",
+				unattendedExistingAction: "skip"
+			})).toBe("skip");
+		});
+	});
+	describe("interactive", () => {
+		it("confirms creation when file does not exist", async () => {
+			const confirm = vi.fn().mockResolvedValue(true);
+			globalExpect(await decideScaffold(makeCtx({ prompts: {
+				confirm,
+				select: vi.fn(),
+				isCancel: () => false
+			} }), {
+				label: "biome.json",
+				fileExists: false,
+				patchHint: "x"
+			})).toBe("create");
+			globalExpect(confirm).toHaveBeenCalledWith(globalExpect.objectContaining({ message: globalExpect.stringContaining("biome.json") }));
+		});
+		it("returns 'skip' when user declines the create confirm", async () => {
+			globalExpect(await decideScaffold(makeCtx({ prompts: {
+				confirm: vi.fn().mockResolvedValue(false),
+				select: vi.fn(),
+				isCancel: () => false
+			} }), {
+				label: "biome.json",
+				fileExists: false,
+				patchHint: "x"
+			})).toBe("skip");
+		});
+		it("shows the patch/skip/overwrite select when file exists", async () => {
+			const select = vi.fn().mockResolvedValue("overwrite");
+			globalExpect(await decideScaffold(makeCtx({ prompts: {
+				confirm: vi.fn(),
+				select,
+				isCancel: () => false
+			} }), {
+				label: "biome.json",
+				fileExists: true,
+				patchHint: "add @rrlab/biome-config to extends"
+			})).toBe("overwrite");
+			const call = select.mock.calls[0]?.[0];
+			globalExpect(call.options.map((o) => o.value).sort()).toEqual([
+				"overwrite",
+				"patch",
+				"skip"
+			]);
+			globalExpect(call.options.find((o) => o.value === "patch")?.label).toMatch(/add @rrlab\/biome-config to extends/);
+		});
+		it("throws 'Cancelled by user.' when the user cancels", async () => {
+			const cancelSymbol = Symbol("cancel");
+			await globalExpect(decideScaffold(makeCtx({ prompts: {
+				confirm: vi.fn().mockResolvedValue(cancelSymbol),
+				select: vi.fn(),
+				isCancel: (v) => v === cancelSymbol
+			} }), {
+				label: "x",
+				fileExists: false,
+				patchHint: "y"
+			})).rejects.toThrow("Cancelled by user.");
+		});
+	});
+});
+//#endregion
+export {};

package/dist/plugin/__tests__/define-plugin.test.d.mts

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

package/dist/plugin/__tests__/define-plugin.test.mjs

@@ -0,0 +1,130 @@
+import { ToolService } from "../tool-service.mjs";
+import { definePlugin } from "../define-plugin.mjs";
+import { i as it, r as describe, t as globalExpect } from "../../test.DNmyFkvJ-09ScyH13.mjs";
+//#region src/lib/plugin/__tests__/define-plugin.test.ts
+function ctx() {
+	return {
+		shell: {},
+		logger: {},
+		appPkg: { dirPath: process.cwd() },
+		binPkg: { dirPath: process.cwd() },
+		cwd: process.cwd()
+	};
+}
+const FROM = import.meta.url;
+const emptyReport = {
+	ok: true,
+	output: ""
+};
+var FakeBiome = class extends ToolService {
+	constructor() {
+		super({
+			pkg: "@biomejs/biome",
+			bin: "biome",
+			color: (s) => s,
+			shellService: {},
+			from: FROM
+		});
+	}
+	async lint() {
+		return emptyReport;
+	}
+	async format() {
+		return emptyReport;
+	}
+	async check() {
+		return emptyReport;
+	}
+};
+var FakeTsc = class extends ToolService {
+	constructor() {
+		super({
+			pkg: "typescript",
+			bin: "tsc",
+			color: (s) => s,
+			shellService: {},
+			from: FROM
+		});
+	}
+	async check() {
+		return emptyReport;
+	}
+};
+var MissingService = class extends ToolService {
+	constructor() {
+		super({
+			bin: "ghostly-bin-that-does-not-exist",
+			color: (s) => s,
+			shellService: {},
+			from: FROM
+		});
+	}
+	async lint() {
+		return emptyReport;
+	}
+};
+describe("definePlugin", () => {
+	it("returns a Plugin shape the registry expects", async () => {
+		const plugin = definePlugin({
+			name: "fake-linter",
+			apiVersion: 1,
+			color: (s) => s,
+			services: () => ({ lint: new FakeBiome() })
+		})();
+		globalExpect(plugin.name).toBe("fake-linter");
+		globalExpect(plugin.apiVersion).toBe(1);
+		globalExpect(typeof plugin.services).toBe("function");
+		const caps = await plugin.services(ctx());
+		globalExpect(Object.keys(caps)).toEqual(["lint"]);
+	});
+	it("filters capabilities by 'only'", async () => {
+		const caps = await definePlugin({
+			name: "biome",
+			apiVersion: 1,
+			color: (s) => s,
+			services: () => {
+				const svc = new FakeBiome();
+				return {
+					lint: svc,
+					format: svc,
+					jscheck: svc
+				};
+			}
+		})({ only: ["lint", "format"] }).services(ctx());
+		globalExpect(Object.keys(caps).sort()).toEqual(["format", "lint"]);
+	});
+	it("throws on unknown kind in 'only' with the canonical message", async () => {
+		await globalExpect(definePlugin({
+			name: "biome",
+			apiVersion: 1,
+			color: (s) => s,
+			services: () => {
+				const svc = new FakeBiome();
+				return {
+					lint: svc,
+					format: svc,
+					jscheck: svc
+				};
+			}
+		})({ only: ["tsc"] }).services(ctx())).rejects.toThrow(/@rrlab\/biome-plugin: unknown capability 'tsc' in 'only'\. Available: /);
+	});
+	it("throws when a required pkg is missing in the host", async () => {
+		await globalExpect(definePlugin({
+			name: "ghostly",
+			apiVersion: 1,
+			color: (s) => s,
+			services: () => ({ lint: new MissingService() })
+		})().services(ctx())).rejects.toThrow(/@rrlab\/ghostly-plugin requires ghostly-bin-that-does-not-exist to be installed/);
+	});
+	it("succeeds when distinct services share a pkg (deduplicated probe)", async () => {
+		const caps = await definePlugin({
+			name: "ts",
+			apiVersion: 1,
+			color: (s) => s,
+			services: () => ({ typecheck: new FakeTsc() })
+		})().services(ctx());
+		globalExpect(Object.keys(caps)).toEqual(["typecheck"]);
+	});
+});
+//#endregion
+export {};

package/dist/plugin/__tests__/pick-preset.test.d.mts

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

package/dist/plugin/__tests__/pick-preset.test.mjs

@@ -0,0 +1,72 @@
+import { pickPreset } from "../pick-preset.mjs";
+import { i as it, n as vi, r as describe, t as globalExpect } from "../../test.DNmyFkvJ-09ScyH13.mjs";
+//#region src/lib/plugin/__tests__/pick-preset.test.ts
+function makeCtx(overrides = {}) {
+	return {
+		shell: {},
+		logger: {},
+		appPkg: { dirPath: process.cwd() },
+		prompts: overrides.prompts ?? {},
+		flags: {
+			force: false,
+			yes: false,
+			nonInteractive: false,
+			...overrides.flags
+		},
+		release: {}
+	};
+}
+const PRESETS = {
+	lib: { label: "Library" },
+	bin: { label: "CLI / Node binary" }
+};
+describe("pickPreset", () => {
+	it("returns the defaultPreset under --yes", async () => {
+		globalExpect(await pickPreset(makeCtx({ flags: { yes: true } }), {
+			message: "Which kind of build?",
+			presets: PRESETS,
+			defaultPreset: "lib"
+		})).toBe("lib");
+	});
+	it("returns the defaultPreset under non-interactive", async () => {
+		globalExpect(await pickPreset(makeCtx({ flags: { nonInteractive: true } }), {
+			message: "x",
+			presets: PRESETS,
+			defaultPreset: "bin"
+		})).toBe("bin");
+	});
+	it("returns the user's interactive choice", async () => {
+		const select = vi.fn().mockResolvedValue("bin");
+		globalExpect(await pickPreset(makeCtx({ prompts: {
+			confirm: vi.fn(),
+			select,
+			isCancel: () => false
+		} }), {
+			message: "Which kind of build?",
+			presets: PRESETS,
+			defaultPreset: "lib"
+		})).toBe("bin");
+		const call = select.mock.calls[0]?.[0];
+		globalExpect(call.options).toEqual([{
+			value: "lib",
+			label: "Library"
+		}, {
+			value: "bin",
+			label: "CLI / Node binary"
+		}]);
+	});
+	it("throws 'Cancelled by user.' when the user cancels", async () => {
+		const cancelSymbol = Symbol("cancel");
+		await globalExpect(pickPreset(makeCtx({ prompts: {
+			confirm: vi.fn(),
+			select: vi.fn().mockResolvedValue(cancelSymbol),
+			isCancel: (v) => v === cancelSymbol
+		} }), {
+			message: "x",
+			presets: PRESETS,
+			defaultPreset: "lib"
+		})).rejects.toThrow("Cancelled by user.");
+	});
+});
+//#endregion
+export {};

package/dist/plugin/__tests__/registry.test.d.mts

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

package/dist/plugin/__tests__/registry.test.mjs

@@ -0,0 +1,104 @@
+import { t as PluginRegistry } from "../../registry-BgqfKK5L.mjs";
+import { i as it, r as describe, t as globalExpect } from "../../test.DNmyFkvJ-09ScyH13.mjs";
+//#region src/lib/plugin/__tests__/registry.test.ts
+function plugin(name) {
+	return {
+		name,
+		ui: name,
+		color: (str) => str,
+		apiVersion: 1,
+		services: async () => ({})
+	};
+}
+async function okReport() {
+	return {
+		ok: true,
+		output: ""
+	};
+}
+function fakeLinter() {
+	return {
+		ui: "fake",
+		lint: okReport,
+		doctor: okReport
+	};
+}
+function fakeFormatter() {
+	return {
+		ui: "fake",
+		format: okReport,
+		doctor: okReport
+	};
+}
+function fakeTypeChecker() {
+	return {
+		ui: "fake",
+		check: okReport,
+		doctor: okReport
+	};
+}
+function fakePacker() {
+	return {
+		ui: "fake",
+		pack: okReport,
+		doctor: okReport
+	};
+}
+describe("PluginRegistry", () => {
+	describe("getService(capability)", () => {
+		it("returns undefined when no plugin provides the capability", () => {
+			globalExpect(new PluginRegistry().getService("lint")).toBeUndefined();
+		});
+		it("returns the impl when exactly one plugin provides the capability", () => {
+			const registry = new PluginRegistry();
+			const linter = fakeLinter();
+			registry.register(plugin("biome"), { lint: linter });
+			globalExpect(registry.getService("lint")).toBe(linter);
+		});
+		it("does not collide across kinds", () => {
+			const registry = new PluginRegistry();
+			const linter = fakeLinter();
+			const formatter = fakeFormatter();
+			registry.register(plugin("oxc"), {
+				lint: linter,
+				format: formatter
+			});
+			globalExpect(registry.getService("lint")).toBe(linter);
+			globalExpect(registry.getService("format")).toBe(formatter);
+			globalExpect(registry.getService("jscheck")).toBeUndefined();
+		});
+		it("throws when two plugins provide the same capability, listing both", () => {
+			const registry = new PluginRegistry();
+			registry.register(plugin("biome"), { lint: fakeLinter() });
+			registry.register(plugin("oxc"), { lint: fakeLinter() });
+			globalExpect(() => registry.getService("lint")).toThrowError(/biome.*oxc|oxc.*biome/);
+		});
+		it("suggests the 'only' option when reporting multi-provider conflicts", () => {
+			const registry = new PluginRegistry();
+			registry.register(plugin("biome"), { lint: fakeLinter() });
+			registry.register(plugin("oxc"), { lint: fakeLinter() });
+			globalExpect(() => registry.getService("lint")).toThrowError(/only:\s*\['lint'\]/);
+		});
+		it("supports typecheck and pack kinds", () => {
+			const registry = new PluginRegistry();
+			const tc = fakeTypeChecker();
+			const packer = fakePacker();
+			registry.register(plugin("ts"), { typecheck: tc });
+			registry.register(plugin("tsdown"), { pack: packer });
+			globalExpect(registry.getService("typecheck")).toBe(tc);
+			globalExpect(registry.getService("pack")).toBe(packer);
+		});
+	});
+	describe("providersOf(capability)", () => {
+		it("returns every plugin that provides the capability", () => {
+			const registry = new PluginRegistry();
+			registry.register(plugin("biome"), { lint: fakeLinter() });
+			registry.register(plugin("oxc"), { lint: fakeLinter() });
+			registry.register(plugin("tsdown"), { pack: fakePacker() });
+			globalExpect(registry.providersOf("lint").map((p) => p.plugin.name).sort()).toEqual(["biome", "oxc"]);
+			globalExpect(registry.providersOf("format")).toEqual([]);
+		});
+	});
+});
+//#endregion
+export {};

package/dist/plugin/bin-probe.d.mts

@@ -0,0 +1,4 @@
+//#region src/lib/plugin/bin-probe.d.ts
+declare function probeBins(services: readonly unknown[], pluginName: string): Promise<void>;
+//#endregion
+export { probeBins };

package/dist/plugin/bin-probe.mjs

@@ -0,0 +1,22 @@
+import { ToolService } from "./tool-service.mjs";
+//#region src/lib/plugin/bin-probe.ts
+async function probeBins(services, pluginName) {
+	const toolServices = services.filter((s) => s instanceof ToolService);
+	const distinct = /* @__PURE__ */ new Map();
+	for (const svc of toolServices) if (!distinct.has(svc.pkg)) distinct.set(svc.pkg, svc);
+	if (distinct.size === 0) return;
+	const probes = [...distinct.values()].map(async (svc) => {
+		try {
+			await svc.getBinDir();
+		} catch {
+			return svc.pkg;
+		}
+		return null;
+	});
+	const missing = (await Promise.all(probes)).filter((p) => p !== null);
+	if (missing.length === 0) return;
+	const pkgName = `@rrlab/${pluginName}-plugin`;
+	throw new Error(`${pkgName} requires ${missing.join(", ")} to be installed in the host project. Run: rr plugins add ${pluginName}  (or: pnpm add -D ${missing.join(" ")})`);
+}
+//#endregion
+export { probeBins };

package/dist/plugin/decide-scaffold.d.mts

@@ -0,0 +1,18 @@
+import { i as InstallContext } from "../types-Iu4IyWof.mjs";
+
+//#region src/lib/plugin/decide-scaffold.d.ts
+type ScaffoldDecision = "create" | "patch" | "overwrite" | "skip";
+type DecideScaffoldOptions = {
+  /** The config file label shown to the user (e.g. `"biome.json"`, `"tsdown.config.ts"`). */label: string; /** Whether the file currently exists in the app project. */
+  fileExists: boolean; /** Short description of what "patch" does, shown in the select option. */
+  patchHint: string;
+  /**
+   * What to return when the file exists and the run is unattended (`--yes` / non-interactive).
+   * - `"patch"` (default): assume the user wants to merge our config into theirs (safe for JSON we can edit).
+   * - `"skip"`: assume the user owns the file (right for TS modules we'd otherwise rewrite blindly).
+   */
+  unattendedExistingAction?: "patch" | "skip";
+};
+declare function decideScaffold(ctx: InstallContext, opts: DecideScaffoldOptions): Promise<ScaffoldDecision>;
+//#endregion
+export { DecideScaffoldOptions, ScaffoldDecision, decideScaffold };

package/dist/plugin/decide-scaffold.mjs

@@ -0,0 +1,36 @@
+//#region src/lib/plugin/decide-scaffold.ts
+async function decideScaffold(ctx, opts) {
+	const { label, fileExists, patchHint, unattendedExistingAction = "patch" } = opts;
+	if (!fileExists) {
+		if (ctx.flags.yes || ctx.flags.nonInteractive) return "create";
+		const choice = await ctx.prompts.confirm({
+			message: `Scaffold ${label}?`,
+			initialValue: true
+		});
+		if (ctx.prompts.isCancel(choice)) throw new Error("Cancelled by user.");
+		return choice ? "create" : "skip";
+	}
+	if (ctx.flags.yes || ctx.flags.nonInteractive) return unattendedExistingAction;
+	const choice = await ctx.prompts.select({
+		message: `${label} already exists. What do you want to do?`,
+		options: [
+			{
+				value: "patch",
+				label: `Patch — ${patchHint}`
+			},
+			{
+				value: "skip",
+				label: "Skip — leave it alone"
+			},
+			{
+				value: "overwrite",
+				label: "Overwrite — replace with a fresh scaffold"
+			}
+		],
+		initialValue: "patch"
+	});
+	if (ctx.prompts.isCancel(choice)) throw new Error("Cancelled by user.");
+	return choice;
+}
+//#endregion
+export { decideScaffold };

package/dist/plugin/define-plugin.d.mts

@@ -0,0 +1,17 @@
+import { c as Plugin, d as PluginServices, f as UninstallContext, i as InstallContext, l as PluginCapability, m as UninstallResult, o as InstallResult, u as PluginContext } from "../types-Iu4IyWof.mjs";
+
+//#region src/lib/plugin/define-plugin.d.ts
+type PluginDefinition<TServices extends PluginServices> = {
+  apiVersion: 1;
+  name: string;
+  color: (value: string) => string;
+  services(ctx: PluginContext): TServices | Promise<TServices>;
+  install?(this: void, ctx: InstallContext): Promise<InstallResult>;
+  uninstall?(this: void, ctx: UninstallContext): Promise<UninstallResult>;
+};
+type Options<TKind extends PluginCapability> = {
+  only?: readonly TKind[];
+};
+declare function definePlugin<TServices extends PluginServices>(definition: PluginDefinition<TServices>): (options?: Options<keyof TServices & PluginCapability>) => Plugin;
+//#endregion
+export { PluginDefinition, definePlugin };

package/dist/plugin/define-plugin.mjs

@@ -0,0 +1,25 @@
+import { probeBins } from "./bin-probe.mjs";
+//#region src/lib/plugin/define-plugin.ts
+function definePlugin(definition) {
+	return (options) => {
+		const only = options?.only;
+		const pkgName = `@rrlab/${definition.name}-plugin`;
+		return {
+			name: definition.name,
+			color: definition.color,
+			ui: definition.color(definition.name),
+			apiVersion: definition.apiVersion,
+			install: definition.install,
+			uninstall: definition.uninstall,
+			async services(ctx) {
+				const services = await definition.services(ctx);
+				await probeBins(Object.values(services), definition.name);
+				if (!only) return services;
+				for (const k of only) if (!(k in services)) throw new Error(`${pkgName}: unknown capability '${k}' in 'only'. Available: ${Object.keys(services).join(", ")}.`);
+				return Object.fromEntries(only.map((capability) => [capability, services[capability]]));
+			}
+		};
+	};
+}
+//#endregion
+export { definePlugin };

package/dist/plugin/directory.d.mts

@@ -0,0 +1,47 @@
+import { l as PluginCapability } from "../types-Iu4IyWof.mjs";
+
+//#region src/lib/plugin/directory.d.ts
+declare const PLUGINS_DIRECTORY: {
+  readonly ts: {
+    readonly pkg: "@rrlab/ts-plugin";
+    readonly name: "ts";
+    readonly capabilities: ["typecheck"];
+  };
+  readonly biome: {
+    readonly pkg: "@rrlab/biome-plugin";
+    readonly name: "biome";
+    readonly capabilities: ["format", "jscheck", "lint"];
+  };
+  readonly oxc: {
+    readonly pkg: "@rrlab/oxc-plugin";
+    readonly name: "oxc";
+    readonly capabilities: ["format", "lint", "jscheck", "typecheck"];
+  };
+  readonly tsdown: {
+    readonly pkg: "@rrlab/tsdown-plugin";
+    readonly name: "tsdown";
+    readonly capabilities: ["pack"];
+  };
+};
+type PluginName = keyof typeof PLUGINS_DIRECTORY;
+declare function allPluginNames(): readonly PluginName[];
+declare function isPluginName(name: string): name is PluginName;
+declare function providersOf(capability: PluginCapability): ({
+  readonly pkg: "@rrlab/ts-plugin";
+  readonly name: "ts";
+  readonly capabilities: ["typecheck"];
+} | {
+  readonly pkg: "@rrlab/biome-plugin";
+  readonly name: "biome";
+  readonly capabilities: ["format", "jscheck", "lint"];
+} | {
+  readonly pkg: "@rrlab/oxc-plugin";
+  readonly name: "oxc";
+  readonly capabilities: ["format", "lint", "jscheck", "typecheck"];
+} | {
+  readonly pkg: "@rrlab/tsdown-plugin";
+  readonly name: "tsdown";
+  readonly capabilities: ["pack"];
+})[];
+//#endregion
+export { PLUGINS_DIRECTORY, PluginName, allPluginNames, isPluginName, providersOf };