greenly 1.0.1 → 1.1.1

package/README.md

@@ -1,17 +1,47 @@
-# greenly
+<h1>
+  <img src="https://raw.githubusercontent.com/yusifaliyevpro/greenly/main/assets/greenly.svg" alt="" height="34" align="top" />
+  greenly
+</h1>
 
-> Config-driven project check runner. Define your lint / format / typecheck / test steps once in `greenly.config.ts` and run them with a single command.
+[![npm version](https://img.shields.io/npm/v/greenly?color=3fb950&label=npm)](https://www.npmjs.com/package/greenly)
+[![npm downloads](https://img.shields.io/npm/dm/greenly?color=3fb950)](https://www.npmjs.com/package/greenly)
+[![unpacked size](https://img.shields.io/npm/unpacked-size/greenly?color=3fb950)](https://www.npmjs.com/package/greenly)
+[![Socket Badge](https://badge.socket.dev/npm/package/greenly/1.0.1)](https://socket.dev/npm/package/greenly)
+[![PR Checks](https://github.com/yusifaliyevpro/greenly/actions/workflows/pr-checks.yml/badge.svg)](https://github.com/yusifaliyevpro/greenly/actions/workflows/pr-checks.yml)
+[![license](https://img.shields.io/npm/l/greenly?color=3fb950)](https://github.com/yusifaliyevpro/greenly/blob/main/LICENSE)
 
-Stop copy-pasting a `pr-checks` script into every repo. Describe your checks in a typed config, and `greenly` runs them in order, streams their output, and offers to auto-fix the ones that can be fixed.
+> Config-driven project check runner. Define your lint / format / typecheck / test / custom steps once in `greenly.config.ts` and run them with a single command.
+
+## Why greenly
+
+**greenly runs all your lint, format, typecheck, test, build, and custom checks from one config file with a single command.**
+
+Instead of pushing and waiting for CI to catch a formatting slip or a type error, run
+`pnpm greenly` before you open a PR. It puts your CI checks and local checks in the same
+place, so if everything is green locally, it is green in CI. Checks run in order with
+their output streamed live, and greenly offers to auto-fix the ones that have a fixer.
+
+It works where your tools do. In an interactive terminal greenly prompts before running a
+fixer; in an **agent terminal or CI (non-TTY)** it skips prompts and just reports pass or
+fail, so it never hangs and an agent can run `greenly` directly.
+
+## Quick start
+
+Run this and greenly sets everything up for you, based on the tools your project already uses:
+
+```bash
+pnpx greenly init
+# or: npx greenly init
+```
 
 ## Install
 
+Or set it up manually:
+
 ```bash
 pnpm add -D greenly
 ```
 
-## Quick start
-
 Create a `greenly.config.ts` at your project root:
 
 ```ts
@@ -51,6 +81,37 @@ Or wire it into your scripts so `pnpm check` works too:
 - Checks marked `optional: true` warn on failure but never fail the overall run.
 - greenly exits with code `1` if any non-optional check is still failing, otherwise `0`.
 
+## Use it in CI
+
+The same command you run locally is the command CI runs. Replace your separate check
+steps with one:
+
+```diff
+       - run: pnpm install --frozen-lockfile
+
+-      - name: TypeScript
+-        run: pnpm tsc --noEmit
+-
+-      - name: Oxfmt
+-        run: pnpm fmt:check
+-
+-      - name: Oxlint
+-        run: pnpm lint
+-
+-      - name: Tests
+-        run: pnpm test
+-
+-      - name: Build
+-        run: pnpm build
+-
+-      - name: Version
+-        run: node --no-warnings scripts/version-check.ts
+-
++      # pnpm greenly
++      - name: Run checks
++        run: pnpm check
+```
+
 ## Config reference
 
 | Field               | Type                                       | Description                                                               |
@@ -104,10 +165,12 @@ greenly.config.js   greenly.config.mjs   greenly.config.cjs
 greenly.config.json
 ```
 
-## CLI flags
+## CLI
 
-| Flag                   | Description                                                              |
+| Command / Flag         | Description                                                              |
 | ---------------------- | ------------------------------------------------------------------------ |
+| `greenly`              | Run the checks from `greenly.config.*`.                                  |
+| `greenly init`         | Set up a config by answering a few questions, then install greenly.      |
 | `-y`, `--yes`, `--fix` | Auto-run every `onFail` fixer without prompting (great for CI / agents). |
 | `--no-fix`             | Run all checks, never prompt or fix, just report.                        |
 | `-v`, `--version`      | Print the version.                                                       |

package/dist/cli.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
-import { existsSync } from "node:fs";
-import { resolve } from "node:path";
-import { loadConfig } from "c12";
-import { execSync } from "node:child_process";
-import { cancel, confirm, isCancel } from "@clack/prompts";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { createJiti } from "jiti";
+import { exec, execSync } from "node:child_process";
+import { promisify } from "node:util";
+import { cancel, confirm, intro, isCancel, log, multiselect, outro, select, spinner, text } from "@clack/prompts";
 //#region package.json
-var version = "1.0.1";
+var name = "greenly";
+var version = "1.1.1";
 //#endregion
 //#region src/lib/args.ts
 function parseArgs(argv) {
@@ -40,8 +43,7 @@ const colors = {
 	cyan: wrap(36, 39)
 };
 //#endregion
-//#region src/lib/config.ts
-const CONFIG_BASENAME = "greenly.config";
+//#region src/lib/constants.ts
 const CONFIG_EXTENSIONS = [
 	"ts",
 	"mts",
@@ -51,6 +53,9 @@ const CONFIG_EXTENSIONS = [
 	"cjs",
 	"json"
 ];
+//#endregion
+//#region src/lib/config.ts
+const CONFIG_BASENAME = "greenly.config";
 var ConfigNotFoundError = class extends Error {
 	cwd;
 	constructor(cwd) {
@@ -76,10 +81,7 @@ function findConfigFile(cwd = process.cwd()) {
 async function loadGreenlyConfig(cwd = process.cwd()) {
 	const configFile = findConfigFile(cwd);
 	if (!configFile) throw new ConfigNotFoundError(cwd);
-	const { config } = await loadConfig({
-		cwd,
-		configFile
-	});
+	const config = await createJiti(pathToFileURL(resolve(cwd, "greenly.config")).href).import(configFile, { default: true });
 	if (!config || typeof config !== "object") throw new ConfigInvalidError(configFile, "config must export an object");
 	if (!Array.isArray(config.checks) || config.checks.length === 0) throw new ConfigInvalidError(configFile, `"checks" must be a non-empty array`);
 	for (const [i, check] of config.checks.entries()) {
@@ -92,6 +94,398 @@ async function loadGreenlyConfig(cwd = process.cwd()) {
 	};
 }
 //#endregion
+//#region src/lib/utils.ts
+function installCommand(pm) {
+	switch (pm) {
+		case "pnpm": return "pnpm add -D greenly@latest";
+		case "yarn": return "yarn add -D greenly@latest";
+		case "bun": return "bun add -d greenly@latest";
+		default: return "npm install -D greenly@latest";
+	}
+}
+function detectLockfiles(cwd) {
+	return [
+		"pnpm-lock.yaml",
+		"yarn.lock",
+		"package-lock.json",
+		"bun.lockb",
+		"bun.lock"
+	].filter((f) => existsSync(join(cwd, f)));
+}
+function detectPackageManager(userAgent, lockfiles) {
+	const ua = userAgent ?? "";
+	if (ua.startsWith("pnpm")) return "pnpm";
+	if (ua.startsWith("yarn")) return "yarn";
+	if (ua.startsWith("bun")) return "bun";
+	if (ua.startsWith("npm")) return "npm";
+	if (lockfiles.includes("pnpm-lock.yaml")) return "pnpm";
+	if (lockfiles.includes("yarn.lock")) return "yarn";
+	if (lockfiles.includes("bun.lockb") || lockfiles.includes("bun.lock")) return "bun";
+	return "npm";
+}
+//#endregion
+//#region src/lib/version.ts
+const parse = (v) => {
+	const [core = "", pre = ""] = v.trim().replace(/^[v^~>=< ]+/, "").split("-", 2);
+	return {
+		nums: core.split(".").map((n) => Number.parseInt(n, 10) || 0),
+		pre
+	};
+};
+function compareVersions(a, b) {
+	const pa = parse(a);
+	const pb = parse(b);
+	for (let i = 0; i < 3; i++) {
+		const diff = (pa.nums[i] ?? 0) - (pb.nums[i] ?? 0);
+		if (diff !== 0) return diff > 0 ? 1 : -1;
+	}
+	if (pa.pre === pb.pre) return 0;
+	if (pa.pre === "") return 1;
+	if (pb.pre === "") return -1;
+	return pa.pre > pb.pre ? 1 : -1;
+}
+function isNewer(latest, current) {
+	return compareVersions(latest, current) > 0;
+}
+async function fetchLatestVersion(pkg, timeoutMs = 3e3) {
+	try {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), timeoutMs);
+		try {
+			const res = await fetch(`https://registry.npmjs.org/${encodeURIComponent(pkg)}/latest`, {
+				signal: controller.signal,
+				headers: { accept: "application/vnd.npm.install-v1+json" }
+			});
+			if (!res.ok) return null;
+			const data = await res.json();
+			if (data && typeof data === "object" && "version" in data) {
+				const version = data.version;
+				return typeof version === "string" ? version : null;
+			}
+			return null;
+		} finally {
+			clearTimeout(timer);
+		}
+	} catch {
+		return null;
+	}
+}
+async function checkForUpdate(pkg, current) {
+	const latest = await fetchLatestVersion(pkg);
+	if (latest && isNewer(latest, current)) return {
+		current,
+		latest
+	};
+	return null;
+}
+//#endregion
+//#region src/lib/init.ts
+const execAsync = promisify(exec);
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function scriptCommand(ctx, candidates) {
+	const found = candidates.find((s) => ctx.scripts.has(s));
+	return found ? `${ctx.run} ${found}` : null;
+}
+const dep = (name) => (deps) => deps.has(name);
+const CHECK_PRESETS = [
+	{
+		value: "typescript",
+		label: "TypeScript (tsc)",
+		detect: dep("typescript"),
+		build: (c) => ({
+			name: "TypeScript",
+			command: scriptCommand(c, ["typecheck", "type-check"]) ?? `${c.run} tsc --noEmit${dep("next")(c.deps) ? " --incremental false" : ""}`
+		})
+	},
+	{
+		value: "oxfmt",
+		label: "Oxfmt",
+		detect: dep("oxfmt"),
+		build: (c) => ({
+			name: "Oxfmt",
+			command: scriptCommand(c, ["fmt:check", "format:check"]) ?? `${c.run} oxfmt --check`,
+			onFail: scriptCommand(c, ["fmt", "format"]) ?? `${c.run} oxfmt`
+		})
+	},
+	{
+		value: "prettier",
+		label: "Prettier",
+		detect: dep("prettier"),
+		build: (c) => ({
+			name: "Prettier",
+			command: scriptCommand(c, ["fmt:check", "format:check"]) ?? `${c.run} prettier --check .`,
+			onFail: scriptCommand(c, ["fmt", "format"]) ?? `${c.run} prettier --write .`
+		})
+	},
+	{
+		value: "oxlint",
+		label: "Oxlint",
+		detect: dep("oxlint"),
+		build: (c) => ({
+			name: "Oxlint",
+			command: scriptCommand(c, ["lint"]) ?? `${c.run} oxlint`
+		})
+	},
+	{
+		value: "eslint",
+		label: "ESLint",
+		detect: dep("eslint"),
+		build: (c) => ({
+			name: "ESLint",
+			command: scriptCommand(c, ["lint"]) ?? `${c.run} eslint .`
+		})
+	},
+	{
+		value: "vitest",
+		label: "Tests (Vitest)",
+		detect: dep("vitest"),
+		build: (c) => ({
+			name: "Tests",
+			command: scriptCommand(c, ["test"]) ?? `${c.run} vitest run`
+		})
+	},
+	{
+		value: "expo-doctor",
+		label: "Expo Doctor",
+		detect: dep("expo"),
+		build: (c) => ({
+			name: "Expo Doctor",
+			command: scriptCommand(c, ["doctor"]) ?? `${c.exec} expo-doctor`
+		})
+	},
+	{
+		value: "build",
+		label: "Build",
+		build: (c) => ({
+			name: "Build",
+			command: scriptCommand(c, ["build"]) ?? `${c.run} build`
+		})
+	},
+	{
+		value: "react-doctor",
+		label: "React Doctor",
+		detect: dep("react"),
+		build: (c) => ({
+			name: "React Doctor",
+			command: `${dep("react-doctor")(c.deps) ? c.run : c.exec} react-doctor --verbose`
+		})
+	}
+];
+function pmContext(pm) {
+	switch (pm) {
+		case "pnpm": return {
+			exec: "pnpx",
+			run: "pnpm"
+		};
+		case "yarn": return {
+			exec: "yarn dlx",
+			run: "yarn"
+		};
+		case "bun": return {
+			exec: "bunx",
+			run: "bun run"
+		};
+		default: return {
+			exec: "npx",
+			run: "npm run"
+		};
+	}
+}
+function buildChecks(selected, pm, opts = {}) {
+	const ctx = {
+		...pmContext(pm),
+		deps: opts.deps ?? new Set(),
+		scripts: opts.scripts ?? new Set()
+	};
+	return CHECK_PRESETS.filter((p) => selected.includes(p.value)).map((p) => p.build(ctx));
+}
+function packageScripts(pkg) {
+	const scripts = pkg?.scripts;
+	return isRecord(scripts) ? new Set(Object.keys(scripts)) : new Set();
+}
+function depRecord(pkg, field) {
+	const deps = pkg?.[field];
+	return isRecord(deps) ? deps : null;
+}
+function installedDependencies(pkg) {
+	const names = new Set();
+	for (const field of ["dependencies", "devDependencies"]) {
+		const deps = depRecord(pkg, field);
+		if (deps) for (const key of Object.keys(deps)) names.add(key);
+	}
+	return names;
+}
+function greenlyLocation(pkg) {
+	const inField = (field) => {
+		const deps = depRecord(pkg, field);
+		return deps !== null && "greenly" in deps;
+	};
+	if (inField("devDependencies")) return "dev";
+	if (inField("dependencies")) return "prod";
+	return "none";
+}
+function declaredGreenlyVersion(pkg) {
+	for (const field of ["devDependencies", "dependencies"]) {
+		const version = depRecord(pkg, field)?.greenly;
+		if (typeof version === "string") return version;
+	}
+	return null;
+}
+function shouldOfferInstall(opts) {
+	const { location, declaredVersion, latestVersion } = opts;
+	if (location === "dev" && declaredVersion && latestVersion && !isNewer(latestVersion, declaredVersion)) return false;
+	return true;
+}
+function availablePresets(installed) {
+	return CHECK_PRESETS.filter((p) => !p.detect || p.detect(installed));
+}
+function configFileName(ext) {
+	return `greenly.config.${ext}`;
+}
+function renderCheck(check) {
+	const parts = [`name: ${JSON.stringify(check.name)}`, `command: ${JSON.stringify(check.command)}`];
+	if (check.onFail) parts.push(`onFail: ${JSON.stringify(check.onFail)}`);
+	return `{ ${parts.join(", ")} }`;
+}
+function isEsm(ext, isModule) {
+	if (ext === "ts" || ext === "mts" || ext === "mjs") return true;
+	if (ext === "cts" || ext === "cjs") return false;
+	return isModule;
+}
+function renderConfig(opts) {
+	const { name, checks, ext, isModule } = opts;
+	if (ext === "json") return `${JSON.stringify({
+		name,
+		checks
+	}, null, 2)}\n`;
+	const body = checks.map((c) => `    ${renderCheck(c)},`).join("\n");
+	const object = `{\n  name: ${JSON.stringify(name)},\n  checks: [\n${body}\n  ],\n}`;
+	if (isEsm(ext, isModule)) return `import { defineConfig } from "greenly";\n\nexport default defineConfig(${object});\n`;
+	return `const { defineConfig } = require("greenly");\n\nmodule.exports = defineConfig(${object});\n`;
+}
+function withCheckScript(pkg, scriptName) {
+	const scripts = isRecord(pkg.scripts) ? pkg.scripts : {};
+	return {
+		...pkg,
+		scripts: {
+			...scripts,
+			[scriptName]: "greenly"
+		}
+	};
+}
+function readPackageJson(path) {
+	if (!existsSync(path)) return null;
+	try {
+		const parsed = JSON.parse(readFileSync(path, "utf8"));
+		if (isRecord(parsed)) return parsed;
+	} catch {}
+	return null;
+}
+function ensure(value) {
+	if (isCancel(value)) {
+		cancel("init cancelled.");
+		process.exit(0);
+	}
+	return value;
+}
+async function runInit(cwd = process.cwd()) {
+	intro(colors.inverse(" greenly ") + colors.dim(" init "));
+	const pkgPath = join(cwd, "package.json");
+	const pkg = readPackageJson(pkgPath);
+	const defaultName = typeof pkg?.name === "string" ? pkg.name : basename(cwd);
+	const pm = detectPackageManager(process.env.npm_config_user_agent, detectLockfiles(cwd));
+	const latestPromise = fetchLatestVersion("greenly");
+	const name = ensure(await text({
+		message: "Project name (shown in the banner)",
+		initialValue: defaultName,
+		validate: (value) => value?.trim() ? void 0 : "Please enter a project name"
+	}));
+	const ext = ensure(await select({
+		message: "Config file format",
+		options: CONFIG_EXTENSIONS.map((e) => ({
+			value: e,
+			label: configFileName(e)
+		})),
+		initialValue: "ts"
+	}));
+	const scriptName = ensure(await text({
+		message: "Script name to add to package.json",
+		initialValue: "check",
+		validate: (value) => value?.trim() ? void 0 : "Please enter a script name"
+	}));
+	const installed = installedDependencies(pkg);
+	const presets = availablePresets(installed);
+	const selected = ensure(await multiselect({
+		message: "Select the checks to include",
+		options: presets.map((p) => ({
+			value: p.value,
+			label: p.label
+		})),
+		required: true
+	}));
+	const declaredVersion = declaredGreenlyVersion(pkg);
+	const latestVersion = await latestPromise;
+	const alreadyLatest = !shouldOfferInstall({
+		location: greenlyLocation(pkg),
+		declaredVersion,
+		latestVersion
+	});
+	const doInstall = alreadyLatest ? false : ensure(await confirm({
+		message: `Install greenly now with ${pm}?`,
+		initialValue: true
+	}));
+	const fileName = configFileName(ext);
+	const filePath = join(cwd, fileName);
+	if (existsSync(filePath)) {
+		if (!ensure(await confirm({
+			message: `${fileName} already exists. Overwrite it?`,
+			initialValue: false
+		}))) {
+			cancel("Kept the existing config. Nothing changed.");
+			process.exit(0);
+		}
+	}
+	const content = renderConfig({
+		name,
+		checks: buildChecks(selected, pm, {
+			deps: installed,
+			scripts: packageScripts(pkg)
+		}),
+		ext,
+		isModule: pkg?.type === "module"
+	});
+	writeFileSync(filePath, content);
+	log.success(`Created ${colors.bold(fileName)}`);
+	if (pkg) {
+		const current = (isRecord(pkg.scripts) ? pkg.scripts : {})[scriptName];
+		let write = true;
+		if (typeof current === "string" && current !== "greenly") write = ensure(await confirm({
+			message: `Script "${scriptName}" already runs "${current}". Overwrite with "greenly"?`,
+			initialValue: false
+		}));
+		if (write) {
+			writeFileSync(pkgPath, `${JSON.stringify(withCheckScript(pkg, scriptName), null, 2)}\n`);
+			log.success(`Added ${colors.bold(`"${scriptName}": "greenly"`)} to package.json`);
+		}
+	} else log.warn("No package.json found, skipped adding the script.");
+	if (doInstall) {
+		const s = spinner();
+		s.start(`Installing greenly with ${pm}`);
+		try {
+			await execAsync(installCommand(pm), { cwd });
+			s.stop("Installed greenly");
+		} catch {
+			s.stop("Could not install greenly automatically");
+			log.warn(`Run "${installCommand(pm)}" yourself.`);
+		}
+	} else if (alreadyLatest) log.info(`greenly ${colors.bold(declaredVersion ?? "")} already a devDependency at latest, skipped install.`);
+	else log.info(`Skipped install. Run "${installCommand(pm)}" when ready.`);
+	const runCmd = `${pmContext(pm).run} ${scriptName}`;
+	outro(`Done. Run ${colors.bold(runCmd)} to run your checks.`);
+}
+//#endregion
 //#region src/lib/runner.ts
 const MIN_WIDTH = 60;
 function bannerWidth(name) {
@@ -113,7 +507,8 @@ async function runCommand(command) {
 	} catch (error) {
 		return {
 			ok: false,
-			stderr: colors.red(formatThrown(error))
+			stderr: colors.red(formatThrown(error)),
+			error
 		};
 	}
 	try {
@@ -138,7 +533,8 @@ async function runCommand(command) {
 		}
 		return {
 			ok: false,
-			stderr
+			stderr,
+			error
 		};
 	}
 }
@@ -179,6 +575,9 @@ async function runFix(check, error) {
 function fixLabel(check) {
 	return typeof check.onFail === "string" ? `"${check.onFail}"` : "the fix function";
 }
+function fixCommand(check) {
+	return typeof check.onFail === "string" ? check.onFail : "fix function";
+}
 async function runChecks(config, options = {}) {
 	const { autoFix = false, interactive = true } = options;
 	const name = config.name ?? "greenly";
@@ -193,7 +592,7 @@ async function runChecks(config, options = {}) {
 	for (const check of config.checks) {
 		console.log(colors.bold(colors.yellow(`▶ ${check.name}`)));
 		console.log(`  ${colors.cyan(commandLine(check.command))}\n`);
-		const { ok, stderr } = await runCommand(check.command);
+		const { ok, stderr, error } = await runCommand(check.command);
 		if (ok) {
 			console.log(`\n${colors.green(`✔ PASSED: ${check.name}`)}\n`);
 			results.push({
@@ -240,9 +639,8 @@ async function runChecks(config, options = {}) {
 			console.log("\n" + colors.dim(rule("─")) + "\n");
 			continue;
 		}
-		const fixDisplay = typeof check.onFail === "string" ? check.onFail : "fix function";
-		console.log(`\n  ${colors.cyan(`$ ${fixDisplay}`)}\n`);
-		if (await runFix(check, new Error(`${check.name} failed`))) {
+		console.log(`\n  ${colors.cyan(`$ ${fixCommand(check)}`)}\n`);
+		if (await runFix(check, error)) {
 			console.log(`\n${colors.green(`✔ Auto-fixed: ${check.name}`)}\n`);
 			results.push({
 				name: check.name,
@@ -281,6 +679,7 @@ const HELP = `${colors.bold("greenly")} - config-driven project check runner
 
 ${colors.bold("Usage")}
   greenly [options]
+  greenly init        Scaffold a greenly.config file interactively
 
 ${colors.bold("Options")}
   -y, --yes, --fix   Auto-run every onFail fixer without prompting (CI / agents)
@@ -302,8 +701,18 @@ ${colors.bold("Config")}
       ],
     });
 `;
+function printUpdateNotice(info) {
+	const pm = detectPackageManager(process.env.npm_config_user_agent, detectLockfiles(process.cwd()));
+	console.log(colors.yellow(`Update available: greenly ${colors.dim(info.current)} -> ${colors.bold(info.latest)}`));
+	console.log(colors.dim(`Run ${colors.bold(installCommand(pm))} to update.`) + "\n");
+}
 async function main() {
-	const parsed = parseArgs(process.argv.slice(2));
+	const argv = process.argv.slice(2);
+	if (argv[0] === "init") {
+		await runInit();
+		return;
+	}
+	const parsed = parseArgs(argv);
 	if (parsed.help) {
 		console.log(HELP);
 		return;
@@ -312,11 +721,15 @@ async function main() {
 		console.log(version);
 		return;
 	}
-	const mode = resolveMode(parsed, process.stdout.isTTY ?? false);
+	const isTTY = process.stdout.isTTY ?? false;
+	const mode = resolveMode(parsed, isTTY);
+	const updateCheck = isTTY ? checkForUpdate(name, version) : null;
 	try {
 		const { config } = await loadGreenlyConfig();
 		const { exitCode } = await runChecks(config, mode);
 		process.exitCode = exitCode;
+		const update = updateCheck ? await updateCheck : null;
+		if (update) printUpdateNotice(update);
 	} catch (error) {
 		if (error instanceof ConfigNotFoundError || error instanceof ConfigInvalidError) {
 			console.error(colors.red(error.message));

package/dist/index.d.cts

@@ -2,12 +2,12 @@
 /**
  * Context passed to an `onFail` function when a check fails.
  */
-interface OnFailContext {
+type OnFailContext = {
   /** The check that failed. */
   check: GreenlyCheck;
   /** The error thrown while running the check's command. */
   error: unknown;
-}
+};
 /**
  * A function run to fix a failing check. Invoked after the user confirms
  * (or automatically with `--yes`/`--fix`). Throw to signal the fix failed.
@@ -22,7 +22,7 @@ type CommandFn = () => void | Promise<void>;
 /**
  * A single check to run, in order.
  */
-interface GreenlyCheck {
+type GreenlyCheck = {
   /** Label shown while running and in the final summary, e.g. "TypeScript". */
   name: string;
   /**
@@ -42,17 +42,17 @@ interface GreenlyCheck {
    * (no non-zero exit code).
    */
   optional?: boolean;
-}
+};
 /**
  * Greenly configuration. Author it with {@link defineConfig} in a
  * `greenly.config.{ts,js,mts,mjs,cts,cjs,json}` file.
  */
-interface GreenlyConfig {
+type GreenlyConfig = {
   /** Project name shown in the banner. Defaults to the package name / cwd. */
   name?: string;
   /** Ordered list of checks to run. */
   checks: GreenlyCheck[];
-}
+};
 //#endregion
 //#region src/lib/define-config.d.ts
 /**

package/dist/index.d.mts

@@ -2,12 +2,12 @@
 /**
  * Context passed to an `onFail` function when a check fails.
  */
-interface OnFailContext {
+type OnFailContext = {
   /** The check that failed. */
   check: GreenlyCheck;
   /** The error thrown while running the check's command. */
   error: unknown;
-}
+};
 /**
  * A function run to fix a failing check. Invoked after the user confirms
  * (or automatically with `--yes`/`--fix`). Throw to signal the fix failed.
@@ -22,7 +22,7 @@ type CommandFn = () => void | Promise<void>;
 /**
  * A single check to run, in order.
  */
-interface GreenlyCheck {
+type GreenlyCheck = {
   /** Label shown while running and in the final summary, e.g. "TypeScript". */
   name: string;
   /**
@@ -42,17 +42,17 @@ interface GreenlyCheck {
    * (no non-zero exit code).
    */
   optional?: boolean;
-}
+};
 /**
  * Greenly configuration. Author it with {@link defineConfig} in a
  * `greenly.config.{ts,js,mts,mjs,cts,cjs,json}` file.
  */
-interface GreenlyConfig {
+type GreenlyConfig = {
   /** Project name shown in the banner. Defaults to the package name / cwd. */
   name?: string;
   /** Ordered list of checks to run. */
   checks: GreenlyCheck[];
-}
+};
 //#endregion
 //#region src/lib/define-config.d.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "greenly",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "description": "Config-driven project check runner. Define your lint/format/typecheck/test steps in greenly.config.ts and run them with one command.",
   "keywords": [
     "check",
@@ -75,7 +75,7 @@
   },
   "dependencies": {
     "@clack/prompts": "1.7.0",
-    "c12": "3.3.4"
+    "jiti": "2.7.0"
   },
   "devDependencies": {
     "@types/node": "24.13.3",