@rrlab/cli 1.1.0 → 1.1.1-git-4903a88.0

package/dist/plugin/directory.mjs

@@ -0,0 +1,45 @@
+//#region src/lib/plugin/directory.ts
+const PLUGINS_DIRECTORY = {
+	ts: {
+		pkg: "@rrlab/ts-plugin",
+		name: "ts",
+		capabilities: ["typecheck"]
+	},
+	biome: {
+		pkg: "@rrlab/biome-plugin",
+		name: "biome",
+		capabilities: [
+			"format",
+			"jscheck",
+			"lint"
+		]
+	},
+	oxc: {
+		pkg: "@rrlab/oxc-plugin",
+		name: "oxc",
+		capabilities: [
+			"format",
+			"lint",
+			"jscheck",
+			"typecheck"
+		]
+	},
+	tsdown: {
+		pkg: "@rrlab/tsdown-plugin",
+		name: "tsdown",
+		capabilities: ["pack"]
+	}
+};
+function allPluginNames() {
+	return Object.keys(PLUGINS_DIRECTORY);
+}
+function isPluginName(name) {
+	return Object.hasOwn(PLUGINS_DIRECTORY, name);
+}
+function providersOf(capability) {
+	return Object.values(PLUGINS_DIRECTORY).filter((info) => {
+		return info.capabilities.includes(capability);
+	});
+}
+//#endregion
+export { PLUGINS_DIRECTORY, allPluginNames, isPluginName, providersOf };

package/dist/plugin/errors.d.mts

@@ -0,0 +1,11 @@
+//#region src/lib/plugin/errors.d.ts
+/**
+ * Thrown by `PluginRegistry.get` when more than one plugin provides the same
+ * capability. The message is load-bearing for the "ambiguity → user narrows
+ * config" UX (decision 003) — `registry.test.ts` asserts the plugin names appear.
+ */
+declare class MultipleProvidersError extends Error {
+  constructor(kind: string, pluginNames: readonly string[]);
+}
+//#endregion
+export { MultipleProvidersError };

package/dist/plugin/errors.mjs

@@ -0,0 +1,15 @@
+//#region src/lib/plugin/errors.ts
+/**
+* Thrown by `PluginRegistry.get` when more than one plugin provides the same
+* capability. The message is load-bearing for the "ambiguity → user narrows
+* config" UX (decision 003) — `registry.test.ts` asserts the plugin names appear.
+*/
+var MultipleProvidersError = class extends Error {
+	constructor(kind, pluginNames) {
+		const names = pluginNames.join(", ");
+		const example = pluginNames.map((name) => `${name}({ only: ['${kind}'] })`).join(" or ");
+		super(`Multiple plugins provide capability '${kind}': ${names}. Narrow each plugin's capabilities in run-run.config.ts using the 'only' option — e.g. ${example}.`);
+	}
+};
+//#endregion
+export { MultipleProvidersError };

package/dist/plugin/index.d.mts

@@ -0,0 +1,7 @@
+import { a as InstallFlags, c as Plugin, d as PluginServices, f as UninstallContext, g as ReleaseServiceOptions, h as ReleaseService, i as InstallContext, l as PluginCapability, m as UninstallResult, n as ClackPromptsSelectOption, o as InstallResult, p as UninstallFlags, r as FileOp, s as JsonEdit, t as ClackPrompts, u as PluginContext } from "../types-Iu4IyWof.mjs";
+import { a as Linter, c as StaticChecker, d as TypeChecker, i as LintOptions, l as StaticCheckerOptions, n as FormatOptions, o as Packer, r as Formatter, s as RunReport, t as Doctor, u as TypeCheckOptions } from "../tool-DKL6TauZ.mjs";
+import { DecideScaffoldOptions, ScaffoldDecision, decideScaffold } from "./decide-scaffold.mjs";
+import { PluginDefinition, definePlugin } from "./define-plugin.mjs";
+import { PickPresetOptions, pickPreset } from "./pick-preset.mjs";
+import { ToolService, ToolServiceOptions } from "./tool-service.mjs";
+export { type ClackPrompts, type ClackPromptsSelectOption, type DecideScaffoldOptions, type Doctor, type FileOp, type FormatOptions, type Formatter, type InstallContext, type InstallFlags, type InstallResult, type JsonEdit, type LintOptions, type Linter, type Packer, type PickPresetOptions, type Plugin, type PluginCapability, type PluginContext, type PluginDefinition, type PluginServices, ReleaseService, type ReleaseServiceOptions, type RunReport, type ScaffoldDecision, type StaticChecker, type StaticCheckerOptions, ToolService, type ToolServiceOptions, type TypeCheckOptions, type TypeChecker, type UninstallContext, type UninstallFlags, type UninstallResult, decideScaffold, definePlugin, pickPreset };

package/dist/plugin/index.mjs

@@ -0,0 +1,50 @@
+import { ToolService } from "./tool-service.mjs";
+import { decideScaffold } from "./decide-scaffold.mjs";
+import { definePlugin } from "./define-plugin.mjs";
+import { pickPreset } from "./pick-preset.mjs";
+//#region src/services/release.ts
+const REGISTRY = "https://registry.npmjs.org";
+const PROBE_TIMEOUT_MS = 5e3;
+/**
+* Represents the "release" the current `rr plugins add` runs against — the
+* dist-tag the user picked (default: latest), plus the logic to resolve install
+* specs for related packages under that release.
+*
+* - With no `tag`, `resolve()` always returns `"latest"` and never hits the
+*   registry.
+* - With a `tag` (e.g. `"pr-226"`), probes `<pkg>@<tag>`: returns the tag when
+*   it exists, falls back to `"latest"` otherwise so a partial preview release
+*   (where only a subset of packages got published) still installs cleanly.
+* - Per-package result is cached within the service instance.
+*/
+var ReleaseService = class {
+	tag;
+	#fetcher;
+	#cache = /* @__PURE__ */ new Map();
+	constructor(tag, { fetcher = fetch } = {}) {
+		this.tag = tag;
+		this.#fetcher = fetcher;
+	}
+	resolve(pkg) {
+		if (!this.tag || this.tag === "latest") return Promise.resolve("latest");
+		const cached = this.#cache.get(pkg);
+		if (cached) return cached;
+		const promise = this.#probe(pkg);
+		this.#cache.set(pkg, promise);
+		return promise;
+	}
+	async #probe(pkg) {
+		const tag = this.tag;
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+		try {
+			return (await this.#fetcher(`${REGISTRY}/${pkg}/${encodeURIComponent(tag)}`, { signal: controller.signal })).ok ? tag : "latest";
+		} catch {
+			return "latest";
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
+};
+//#endregion
+export { ReleaseService, ToolService, decideScaffold, definePlugin, pickPreset };

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

@@ -0,0 +1,13 @@
+import { i as InstallContext } from "../types-Iu4IyWof.mjs";
+
+//#region src/lib/plugin/pick-preset.d.ts
+type PickPresetOptions<K extends string> = {
+  message: string;
+  presets: Record<K, {
+    label: string;
+  }>;
+  defaultPreset: K;
+};
+declare function pickPreset<K extends string>(ctx: InstallContext, opts: PickPresetOptions<K>): Promise<K>;
+//#endregion
+export { PickPresetOptions, pickPreset };

package/dist/plugin/pick-preset.mjs

@@ -0,0 +1,17 @@
+//#region src/lib/plugin/pick-preset.ts
+async function pickPreset(ctx, opts) {
+	const { message, presets, defaultPreset } = opts;
+	if (ctx.flags.yes || ctx.flags.nonInteractive) return defaultPreset;
+	const choice = await ctx.prompts.select({
+		message,
+		options: Object.entries(presets).map(([value, meta]) => ({
+			value,
+			label: meta.label
+		})),
+		initialValue: defaultPreset
+	});
+	if (ctx.prompts.isCancel(choice)) throw new Error("Cancelled by user.");
+	return choice;
+}
+//#endregion
+export { pickPreset };

package/dist/plugin/registry.d.mts

@@ -0,0 +1,19 @@
+import { c as Plugin, d as PluginServices, l as PluginCapability } from "../types-Iu4IyWof.mjs";
+import { a as Linter, c as StaticChecker, d as TypeChecker, o as Packer, r as Formatter, t as Doctor } from "../tool-DKL6TauZ.mjs";
+
+//#region src/lib/plugin/registry.d.ts
+type Provider<K extends PluginCapability> = {
+  plugin: Plugin;
+  service: NonNullable<PluginServices[K]>;
+};
+declare class PluginRegistry {
+  #private;
+  register(plugin: Plugin, services: PluginServices): void;
+  getServiceOrThrow<K extends PluginCapability>(capability: K): NonNullable<PluginServices[K]>;
+  getService<K extends PluginCapability>(capability: K): NonNullable<PluginServices[K]> | undefined;
+  getAllServices(): NonNullable<(Linter & Doctor) | (Formatter & Doctor) | (StaticChecker & Doctor) | (TypeChecker & Doctor) | (Packer & Doctor) | undefined>[];
+  providersOf<K extends PluginCapability>(capability: K): Provider<K>[];
+  providerOf<K extends PluginCapability>(capability: K): Provider<K> | undefined;
+}
+//#endregion
+export { PluginRegistry };

package/dist/plugin/registry.mjs

@@ -0,0 +1,2 @@
+import { t as PluginRegistry } from "../registry-BgqfKK5L.mjs";
+export { PluginRegistry };

package/dist/plugin/tool-service.d.mts

@@ -0,0 +1,45 @@
+import { s as RunReport } from "../tool-DKL6TauZ.mjs";
+import { ShellService } from "@vlandoss/clibuddy";
+
+//#region src/lib/plugin/tool-service.d.ts
+type ToolServiceOptions = {
+  pkg?: string;
+  bin: string;
+  color: (str: string) => string;
+  shellService: ShellService;
+  /**
+   * Module URL the resolver walks up from when looking for `pkg` in
+   * `node_modules`. Plugins MUST pass their own `import.meta.url` so the
+   * binary is resolved from the plugin's own dependency graph (peer-installed
+   * by the host project), not the kernel's. Kernel-internal services pass
+   * `import.meta.url` of their own module file.
+   */
+  from: string;
+};
+type RunReportOptions = {
+  cwd?: string;
+};
+declare class ToolService {
+  #private;
+  get pkg(): string;
+  get ui(): string;
+  constructor({
+    pkg,
+    bin,
+    color,
+    shellService,
+    from
+  }: ToolServiceOptions);
+  getBinDir(): Promise<string>;
+  /**
+   * Runs the tool capturing its output instead of streaming it, and reports the
+   * verdict straight from the exit code — never a guess parsed from the output.
+   * The board needs the capture to attribute each parallel run's output to its
+   * package; the non-zero exit is returned (not thrown) so every task settles
+   * and the caller can aggregate. See `decisions/013-check-stream-to-capture-contract.md`.
+   */
+  runReport(args?: string[], options?: RunReportOptions): Promise<RunReport>;
+  doctor(): Promise<RunReport>;
+}
+//#endregion
+export { RunReportOptions, ToolService, ToolServiceOptions };

package/dist/plugin/tool-service.mjs

@@ -0,0 +1,64 @@
+import { palette, resolvePackageBin } from "@vlandoss/clibuddy";
+//#region src/lib/plugin/tool-service.ts
+var ToolService = class {
+	#shellService;
+	#pkg;
+	#bin;
+	#from;
+	#ui;
+	get pkg() {
+		return this.#pkg;
+	}
+	get ui() {
+		return this.#ui;
+	}
+	constructor({ pkg, bin, color, shellService, from }) {
+		this.#bin = bin;
+		this.#pkg = pkg ?? bin;
+		this.#ui = color(bin);
+		this.#shellService = shellService;
+		this.#from = from;
+	}
+	async getBinDir() {
+		return resolvePackageBin(this.#pkg, {
+			from: this.#from,
+			binName: this.#bin
+		});
+	}
+	/**
+	* Runs the tool capturing its output instead of streaming it, and reports the
+	* verdict straight from the exit code — never a guess parsed from the output.
+	* The board needs the capture to attribute each parallel run's output to its
+	* package; the non-zero exit is returned (not thrown) so every task settles
+	* and the caller can aggregate. See `decisions/013-check-stream-to-capture-contract.md`.
+	*/
+	async runReport(args = [], options = {}) {
+		const output = await (options.cwd ? this.#shellService.at(options.cwd) : this.#shellService).runCaptured(await this.getBinDir(), args, { throwOnError: false });
+		const header = palette.dim(`$ ${[this.#bin, ...args].join(" ")}`);
+		const body = combine(output.stdout, output.stderr);
+		return {
+			ok: output.exitCode === 0,
+			output: body ? `${header}\n${body}` : header
+		};
+	}
+	async doctor() {
+		const output = await this.#shellService.runCaptured(await this.getBinDir(), ["--help"], { throwOnError: false });
+		const ok = output.exitCode === 0;
+		const command = palette.dim(`$ ${this.#bin} --help`);
+		if (ok) return {
+			ok,
+			output: command
+		};
+		const detail = combine(output.stdout, output.stderr);
+		return {
+			ok,
+			output: detail ? `${command}\n${detail}` : command
+		};
+	}
+};
+/** Joins the non-empty, trimmed streams of a captured run. */
+function combine(stdout, stderr) {
+	return [stdout, stderr].map((stream) => stream?.trim()).filter(Boolean).join("\n");
+}
+//#endregion
+export { ToolService };

package/dist/plugin/types.d.mts

@@ -0,0 +1,3 @@
+import { a as InstallFlags, c as Plugin, d as PluginServices, f as UninstallContext, i as InstallContext, l as PluginCapability, m as UninstallResult, n as ClackPromptsSelectOption, o as InstallResult, p as UninstallFlags, r as FileOp, s as JsonEdit, t as ClackPrompts, u as PluginContext } from "../types-Iu4IyWof.mjs";
+import { a as Linter, c as StaticChecker, d as TypeChecker, i as LintOptions, l as StaticCheckerOptions, n as FormatOptions, o as Packer, r as Formatter, s as RunReport, t as Doctor, u as TypeCheckOptions } from "../tool-DKL6TauZ.mjs";
+export { ClackPrompts, ClackPromptsSelectOption, type Doctor, FileOp, type FormatOptions, type Formatter, InstallContext, InstallFlags, InstallResult, JsonEdit, type LintOptions, type Linter, type Packer, Plugin, PluginCapability, PluginContext, PluginServices, type RunReport, type StaticChecker, type StaticCheckerOptions, type TypeCheckOptions, type TypeChecker, UninstallContext, UninstallFlags, UninstallResult };

package/dist/plugin/types.mjs

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

package/dist/registry-BgqfKK5L.mjs

@@ -0,0 +1,55 @@
+import { providersOf } from "./plugin/directory.mjs";
+import { MultipleProvidersError } from "./plugin/errors.mjs";
+//#region src/errors/missing-plugin.ts
+var MissingPluginError = class extends Error {
+	constructor(capability) {
+		const plugins = providersOf(capability);
+		const pkgList = plugins.map((it) => it.pkg).join(", ");
+		const addList = plugins.map((it) => `rr plugins add ${it.name}`).join(" | ");
+		super(`No plugin provides the '${capability}' capability.` + (pkgList ? `\n  Install one of: ${pkgList}.` : "") + (addList ? `\n  Try: ${addList}.` : ""));
+	}
+};
+//#endregion
+//#region src/lib/plugin/registry.ts
+var PluginRegistry = class {
+	#entries = [];
+	register(plugin, services) {
+		this.#entries.push({
+			plugin,
+			services
+		});
+	}
+	getServiceOrThrow(capability) {
+		const provider = this.providerOf(capability);
+		if (!provider) throw new MissingPluginError(capability);
+		return provider.service;
+	}
+	getService(capability) {
+		return this.providerOf(capability)?.service;
+	}
+	getAllServices() {
+		const seen = /* @__PURE__ */ new Set();
+		for (const { services } of this.#entries) for (const service of Object.values(services)) if (service) seen.add(service);
+		return [...seen];
+	}
+	providersOf(capability) {
+		const providers = [];
+		for (const { plugin, services } of this.#entries) {
+			const service = services[capability];
+			if (service) providers.push({
+				plugin,
+				service
+			});
+		}
+		return providers;
+	}
+	providerOf(capability) {
+		const providers = this.providersOf(capability);
+		const [first, ...rest] = providers;
+		if (!first) return;
+		if (rest.length > 0) throw new MultipleProvidersError(capability, providers.map(({ plugin }) => plugin.name));
+		return first;
+	}
+};
+//#endregion
+export { PluginRegistry as t };