greenly 0.0.1 → 1.0.1

package/README.md

@@ -1,31 +1,120 @@
 # greenly
 
-> 🚧 Coming soon
+> Config-driven project check runner. Define your lint / format / typecheck / test steps once in `greenly.config.ts` and run them with a single command.
 
-A config-driven pre-ship checks runner. Define your preflight steps once in a
-config file, run them with a single command before you ship.
+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.
 
-## Status
+## Install
 
-**This package is under active development and not ready for use yet.**
+```bash
+pnpm add -D greenly
+```
 
-The name is reserved while the first release is being built. Installing it now
-will get you a placeholder. Star or watch the repo to know when `1.0.0` lands.
+## Quick start
 
-## What it will do
+Create a `greenly.config.ts` at your project root:
 
-- Define your check steps in an `greenly.config.ts`
-- Run them all with one command (e.g. `pnpm check`)
-- Clean, interactive output for pass/fail steps
+```ts
+import { defineConfig } from "greenly";
 
-## Install
+export default defineConfig({
+  name: "MyProject",
+  checks: [
+    { name: "TypeScript", command: "pnpm tsc --noEmit" },
+    { name: "Format", command: "pnpm oxfmt --check", onFail: "pnpm oxfmt" },
+    { name: "Lint", command: "pnpm oxlint" },
+    { name: "Build", command: "pnpm build", optional: true },
+  ],
+});
+```
 
-Not yet recommended. Once the first release is out:
+Run it:
 
 ```bash
-npm install -D greenly
+pnpm greenly
+```
+
+Or wire it into your scripts so `pnpm check` works too:
+
+```json
+{
+  "scripts": {
+    "check": "greenly"
+  }
+}
+```
+
+## How it works
+
+- Checks run **in order**. Each `command` runs in your shell with its output streamed live, so failures show up immediately.
+- If a check fails and declares an `onFail`, greenly asks **Yes/No** whether to run the fixer, then continues.
+- 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`.
+
+## Config reference
+
+| Field               | Type                                       | Description                                                               |
+| ------------------- | ------------------------------------------ | ------------------------------------------------------------------------- |
+| `name`              | `string?`                                  | Project name shown in the banner.                                         |
+| `checks`            | `Check[]`                                  | Ordered list of checks.                                                   |
+| `checks[].name`     | `string`                                   | Label shown while running and in the summary.                             |
+| `checks[].command`  | `string \| () => void \| Promise<void>`    | Shell command (e.g. `"pnpm tsc --noEmit"`), or a function run in-process. |
+| `checks[].onFail`   | `string \| (ctx) => void \| Promise<void>` | Fixer run (after a Yes/No prompt) when the check fails.                   |
+| `checks[].optional` | `boolean?`                                 | When `true`, a failure warns instead of failing the run.                  |
+
+`command` can be a function instead of a shell string. It may be async, and it must **throw** (or reject) to mark the check as failed. When it throws, greenly prints only the error's `message` (and its `cause` if present) - not a stack trace - so make the message descriptive:
+
+```ts
+export default defineConfig({
+  checks: [
+    {
+      name: "Env vars",
+      command: () => {
+        if (!process.env.API_KEY) throw new Error("API_KEY is not set");
+      },
+    },
+  ],
+});
 ```
 
+`onFail` can also be a function, useful for custom fix logic:
+
+```ts
+export default defineConfig({
+  checks: [
+    {
+      name: "Generated files",
+      command: "pnpm verify:generated",
+      onFail: async ({ check }) => {
+        await regenerate();
+        console.log(`Regenerated files for ${check.name}`);
+      },
+    },
+  ],
+});
+```
+
+### Config file formats
+
+Any of these are auto-discovered (first match wins, in this order):
+
+```
+greenly.config.ts   greenly.config.mts   greenly.config.cts
+greenly.config.js   greenly.config.mjs   greenly.config.cjs
+greenly.config.json
+```
+
+## CLI flags
+
+| Flag                   | Description                                                              |
+| ---------------------- | ------------------------------------------------------------------------ |
+| `-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.                                                       |
+| `-h`, `--help`         | Show help.                                                               |
+
+When stdout is **not a TTY** (CI, piped output), greenly is non-interactive by default, so it never prompts and nothing hangs. Use `--yes` there to auto-apply fixes.
+
 ## License
 
-MIT
+MIT © [Yusif Aliyev](https://yusifaliyevpro.com)

package/dist/cli.js

@@ -0,0 +1,331 @@
+#!/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";
+//#region package.json
+var version = "1.0.1";
+//#endregion
+//#region src/lib/args.ts
+function parseArgs(argv) {
+	const has = (...flags) => argv.some((a) => flags.includes(a));
+	const noFix = has("--no-fix");
+	return {
+		help: has("-h", "--help"),
+		version: has("-v", "--version"),
+		noFix,
+		autoFix: !noFix && has("-y", "--yes", "--fix")
+	};
+}
+function resolveMode(parsed, isTTY) {
+	return {
+		autoFix: parsed.autoFix,
+		interactive: !parsed.noFix && !parsed.autoFix && isTTY
+	};
+}
+//#endregion
+//#region src/lib/colors.ts
+const enabled = !process.env.NO_COLOR && (process.env.FORCE_COLOR === "1" || (process.stdout?.isTTY ?? false));
+function wrap(open, close) {
+	return (text) => enabled ? `\x1b[${open}m${text}\x1b[${close}m` : text;
+}
+const colors = {
+	bold: wrap(1, 22),
+	dim: wrap(2, 22),
+	inverse: wrap(7, 27),
+	red: wrap(31, 39),
+	green: wrap(32, 39),
+	yellow: wrap(33, 39),
+	cyan: wrap(36, 39)
+};
+//#endregion
+//#region src/lib/config.ts
+const CONFIG_BASENAME = "greenly.config";
+const CONFIG_EXTENSIONS = [
+	"ts",
+	"mts",
+	"cts",
+	"js",
+	"mjs",
+	"cjs",
+	"json"
+];
+var ConfigNotFoundError = class extends Error {
+	cwd;
+	constructor(cwd) {
+		super(`No ${CONFIG_BASENAME} file found in ${cwd}.\nCreate one, e.g. ${CONFIG_BASENAME}.ts:\n\n  import { defineConfig } from "greenly";\n\n  export default defineConfig({\n    name: "MyProject",\n    checks: [{ name: "TypeScript", command: "pnpm tsc --noEmit" }],\n  });`);
+		this.cwd = cwd;
+		this.name = "ConfigNotFoundError";
+	}
+};
+var ConfigInvalidError = class extends Error {
+	configFile;
+	constructor(configFile, detail) {
+		super(`Invalid config in ${configFile}: ${detail}`);
+		this.configFile = configFile;
+		this.name = "ConfigInvalidError";
+	}
+};
+function findConfigFile(cwd = process.cwd()) {
+	for (const ext of CONFIG_EXTENSIONS) {
+		const candidate = resolve(cwd, `${CONFIG_BASENAME}.${ext}`);
+		if (existsSync(candidate)) return candidate;
+	}
+}
+async function loadGreenlyConfig(cwd = process.cwd()) {
+	const configFile = findConfigFile(cwd);
+	if (!configFile) throw new ConfigNotFoundError(cwd);
+	const { config } = await loadConfig({
+		cwd,
+		configFile
+	});
+	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()) {
+		const validCommand = typeof check?.command === "string" || typeof check?.command === "function";
+		if (!check || typeof check.name !== "string" || !validCommand) throw new ConfigInvalidError(configFile, `checks[${i}] must have a string "name" and a string or function "command"`);
+	}
+	return {
+		config,
+		configFile
+	};
+}
+//#endregion
+//#region src/lib/runner.ts
+const MIN_WIDTH = 60;
+function bannerWidth(name) {
+	const base = Math.min(process.stdout.columns ?? MIN_WIDTH, MIN_WIDTH);
+	return Math.max(base, name.length + 6);
+}
+function center(text, width) {
+	const total = Math.max(0, width - text.length);
+	const left = Math.floor(total / 2);
+	return " ".repeat(left) + text + " ".repeat(total - left);
+}
+async function runCommand(command) {
+	if (typeof command === "function") try {
+		await command();
+		return {
+			ok: true,
+			stderr: ""
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			stderr: colors.red(formatThrown(error))
+		};
+	}
+	try {
+		execSync(command, {
+			stdio: [
+				"inherit",
+				"inherit",
+				"pipe"
+			],
+			encoding: "utf8"
+		});
+		return {
+			ok: true,
+			stderr: ""
+		};
+	} catch (error) {
+		let stderr = "";
+		if (error && typeof error === "object" && "stderr" in error) {
+			const raw = error.stderr;
+			if (typeof raw === "string") stderr = raw;
+			else if (Buffer.isBuffer(raw)) stderr = raw.toString("utf8");
+		}
+		return {
+			ok: false,
+			stderr
+		};
+	}
+}
+function describeUnknown(value) {
+	if (value instanceof Error) return value.message || value.name;
+	if (typeof value === "string") return value;
+	if (typeof value === "object" && value !== null) try {
+		return JSON.stringify(value);
+	} catch {
+		return "[object]";
+	}
+	return String(value);
+}
+function formatThrown(error) {
+	if (error instanceof Error) {
+		let message = error.message || error.name;
+		if (error.cause !== void 0) message += `\nCause: ${describeUnknown(error.cause)}`;
+		return message;
+	}
+	return describeUnknown(error);
+}
+function commandLine(command) {
+	if (typeof command === "string") return `$ ${command}`;
+	return command.name ? `→ ${command.name}()` : "→ (function)";
+}
+async function runFix(check, error) {
+	try {
+		if (typeof check.onFail === "string") execSync(check.onFail, { stdio: "inherit" });
+		else if (typeof check.onFail === "function") await check.onFail({
+			check,
+			error
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function fixLabel(check) {
+	return typeof check.onFail === "string" ? `"${check.onFail}"` : "the fix function";
+}
+async function runChecks(config, options = {}) {
+	const { autoFix = false, interactive = true } = options;
+	const name = config.name ?? "greenly";
+	const width = bannerWidth(name);
+	const rule = (char) => char.repeat(width);
+	console.log();
+	console.log(colors.cyan(colors.bold(rule("═"))));
+	console.log(colors.cyan(colors.bold(center(name, width))));
+	console.log(colors.cyan(colors.bold(rule("═"))));
+	console.log();
+	const results = [];
+	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);
+		if (ok) {
+			console.log(`\n${colors.green(`✔ PASSED: ${check.name}`)}\n`);
+			results.push({
+				name: check.name,
+				status: "passed"
+			});
+			console.log(colors.dim(rule("─")) + "\n");
+			continue;
+		}
+		if (stderr) process.stderr.write(stderr.endsWith("\n") ? stderr : `${stderr}\n`);
+		console.log(`\n${colors.red(`✖ FAILED: ${check.name}`)}`);
+		if (check.onFail === void 0) {
+			if (check.optional) console.log(colors.yellow(`  ${check.name} is optional, continuing.`));
+			results.push({
+				name: check.name,
+				status: check.optional ? "warned" : "failed"
+			});
+			console.log("\n" + colors.dim(rule("─")) + "\n");
+			continue;
+		}
+		let shouldFix = autoFix;
+		if (!autoFix && interactive) {
+			const answer = await confirm({
+				message: `Run ${fixLabel(check)} to fix ${colors.bold(check.name)}?`,
+				initialValue: true
+			});
+			if (isCancel(answer)) {
+				cancel("Aborted.");
+				return {
+					results,
+					failed: results.filter((r) => r.status === "failed").length,
+					exitCode: 1
+				};
+			}
+			shouldFix = answer;
+		}
+		if (!shouldFix) {
+			if (!interactive && !autoFix) console.log(colors.dim(`  Fixer available, re-run with --yes to auto-fix.`));
+			else console.log(colors.yellow(`  Skipped fix.`));
+			results.push({
+				name: check.name,
+				status: check.optional ? "warned" : "failed"
+			});
+			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.green(`✔ Auto-fixed: ${check.name}`)}\n`);
+			results.push({
+				name: check.name,
+				status: "fixed"
+			});
+		} else {
+			console.log(`\n${colors.red(`  Auto-fix failed for ${check.name}, please fix manually.`)}\n`);
+			results.push({
+				name: check.name,
+				status: check.optional ? "warned" : "failed"
+			});
+		}
+		console.log(colors.dim(rule("─")) + "\n");
+	}
+	const passed = results.filter((r) => r.status === "passed" || r.status === "fixed").length;
+	const warned = results.filter((r) => r.status === "warned").length;
+	const failedResults = results.filter((r) => r.status === "failed");
+	const failed = failedResults.length;
+	console.log(colors.cyan(colors.bold(rule("═"))));
+	const summary = colors.green(`${passed} passed`) + (warned > 0 ? colors.dim(", ") + colors.yellow(`${warned} warned`) : "") + colors.dim(", ") + (failed > 0 ? colors.red(`${failed} failed`) : colors.dim("0 failed"));
+	console.log(colors.bold(`   Results: ${summary}`));
+	if (failed > 0) {
+		console.log(`\n${colors.red(colors.bold("Failed checks:"))}`);
+		for (const r of failedResults) console.log(colors.red(`  • ${r.name}`));
+		console.log(`\n${colors.red(colors.bold("⚠  Fix the issues above before continuing."))}\n`);
+	} else console.log(`\n${colors.green(colors.bold("✔  All checks passed!"))}\n`);
+	return {
+		results,
+		failed,
+		exitCode: failed > 0 ? 1 : 0
+	};
+}
+//#endregion
+//#region src/cli.ts
+const HELP = `${colors.bold("greenly")} - config-driven project check runner
+
+${colors.bold("Usage")}
+  greenly [options]
+
+${colors.bold("Options")}
+  -y, --yes, --fix   Auto-run every onFail fixer without prompting (CI / agents)
+      --no-fix       Run all checks, never prompt or fix, just report
+  -v, --version      Print version
+  -h, --help         Show this help
+
+${colors.bold("Config")}
+  Add a greenly.config.{ts,js,mts,mjs,cts,cjs,json} file:
+
+    import { defineConfig } from "greenly";
+
+    export default defineConfig({
+      name: "MyProject",
+      checks: [
+        { name: "TypeScript", command: "pnpm tsc --noEmit" },
+        { name: "Format", command: "pnpm oxfmt --check", onFail: "pnpm oxfmt" },
+        { name: "Lint", command: "pnpm oxlint" },
+      ],
+    });
+`;
+async function main() {
+	const parsed = parseArgs(process.argv.slice(2));
+	if (parsed.help) {
+		console.log(HELP);
+		return;
+	}
+	if (parsed.version) {
+		console.log(version);
+		return;
+	}
+	const mode = resolveMode(parsed, process.stdout.isTTY ?? false);
+	try {
+		const { config } = await loadGreenlyConfig();
+		const { exitCode } = await runChecks(config, mode);
+		process.exitCode = exitCode;
+	} catch (error) {
+		if (error instanceof ConfigNotFoundError || error instanceof ConfigInvalidError) {
+			console.error(colors.red(error.message));
+			process.exitCode = 1;
+			return;
+		}
+		throw error;
+	}
+}
+await main();
+//#endregion
+export {};

package/dist/index.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/lib/define-config.ts
+/**
+* Define a Greenly config with full type-checking and editor autocomplete.
+*
+* @example
+* ```ts
+* // greenly.config.ts
+* import { defineConfig } from "greenly";
+*
+* export default defineConfig({
+*   name: "MyProject",
+*   checks: [
+*     { name: "TypeScript", command: "pnpm tsc --noEmit" },
+*     { name: "Format", command: "pnpm oxfmt --check", onFail: "pnpm oxfmt" },
+*     { name: "Lint", command: "pnpm oxlint" },
+*   ],
+* });
+* ```
+*/
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+exports.defineConfig = defineConfig;

package/dist/index.d.cts

@@ -0,0 +1,78 @@
+//#region src/lib/types.d.ts
+/**
+ * Context passed to an `onFail` function when a check fails.
+ */
+interface 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.
+ */
+type OnFailFn = (ctx: OnFailContext) => void | Promise<void>;
+/**
+ * A function run in-process as a check, instead of a shell command. May be
+ * async. Throw (or reject) to mark the check as failed; return to pass. On
+ * failure only the error's `message` (and `cause`) is shown, not a stack trace.
+ */
+type CommandFn = () => void | Promise<void>;
+/**
+ * A single check to run, in order.
+ */
+interface GreenlyCheck {
+  /** Label shown while running and in the final summary, e.g. "TypeScript". */
+  name: string;
+  /**
+   * The check to run: a shell command string (e.g. `"pnpm tsc --noEmit"`), or
+   * a function run in-process instead. A function may be async, and must throw
+   * (or reject) to fail the check.
+   */
+  command: string | CommandFn;
+  /**
+   * Command string, or a function, run to fix the check when it fails.
+   * The user is asked Yes/No first (skipped with `--yes`/`--fix`, or when
+   * running non-interactively). A string is executed as a shell command.
+   */
+  onFail?: string | OnFailFn;
+  /**
+   * When `true`, a failure warns but does not fail the overall run
+   * (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 {
+  /** 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
+/**
+ * Define a Greenly config with full type-checking and editor autocomplete.
+ *
+ * @example
+ * ```ts
+ * // greenly.config.ts
+ * import { defineConfig } from "greenly";
+ *
+ * export default defineConfig({
+ *   name: "MyProject",
+ *   checks: [
+ *     { name: "TypeScript", command: "pnpm tsc --noEmit" },
+ *     { name: "Format", command: "pnpm oxfmt --check", onFail: "pnpm oxfmt" },
+ *     { name: "Lint", command: "pnpm oxlint" },
+ *   ],
+ * });
+ * ```
+ */
+declare function defineConfig(config: GreenlyConfig): GreenlyConfig;
+//#endregion
+export { type CommandFn, type GreenlyCheck, type GreenlyConfig, type OnFailContext, type OnFailFn, defineConfig };

package/dist/index.d.mts

@@ -0,0 +1,78 @@
+//#region src/lib/types.d.ts
+/**
+ * Context passed to an `onFail` function when a check fails.
+ */
+interface 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.
+ */
+type OnFailFn = (ctx: OnFailContext) => void | Promise<void>;
+/**
+ * A function run in-process as a check, instead of a shell command. May be
+ * async. Throw (or reject) to mark the check as failed; return to pass. On
+ * failure only the error's `message` (and `cause`) is shown, not a stack trace.
+ */
+type CommandFn = () => void | Promise<void>;
+/**
+ * A single check to run, in order.
+ */
+interface GreenlyCheck {
+  /** Label shown while running and in the final summary, e.g. "TypeScript". */
+  name: string;
+  /**
+   * The check to run: a shell command string (e.g. `"pnpm tsc --noEmit"`), or
+   * a function run in-process instead. A function may be async, and must throw
+   * (or reject) to fail the check.
+   */
+  command: string | CommandFn;
+  /**
+   * Command string, or a function, run to fix the check when it fails.
+   * The user is asked Yes/No first (skipped with `--yes`/`--fix`, or when
+   * running non-interactively). A string is executed as a shell command.
+   */
+  onFail?: string | OnFailFn;
+  /**
+   * When `true`, a failure warns but does not fail the overall run
+   * (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 {
+  /** 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
+/**
+ * Define a Greenly config with full type-checking and editor autocomplete.
+ *
+ * @example
+ * ```ts
+ * // greenly.config.ts
+ * import { defineConfig } from "greenly";
+ *
+ * export default defineConfig({
+ *   name: "MyProject",
+ *   checks: [
+ *     { name: "TypeScript", command: "pnpm tsc --noEmit" },
+ *     { name: "Format", command: "pnpm oxfmt --check", onFail: "pnpm oxfmt" },
+ *     { name: "Lint", command: "pnpm oxlint" },
+ *   ],
+ * });
+ * ```
+ */
+declare function defineConfig(config: GreenlyConfig): GreenlyConfig;
+//#endregion
+export { type CommandFn, type GreenlyCheck, type GreenlyConfig, type OnFailContext, type OnFailFn, defineConfig };

package/dist/index.mjs

@@ -0,0 +1,24 @@
+//#region src/lib/define-config.ts
+/**
+* Define a Greenly config with full type-checking and editor autocomplete.
+*
+* @example
+* ```ts
+* // greenly.config.ts
+* import { defineConfig } from "greenly";
+*
+* export default defineConfig({
+*   name: "MyProject",
+*   checks: [
+*     { name: "TypeScript", command: "pnpm tsc --noEmit" },
+*     { name: "Format", command: "pnpm oxfmt --check", onFail: "pnpm oxfmt" },
+*     { name: "Lint", command: "pnpm oxlint" },
+*   ],
+* });
+* ```
+*/
+function defineConfig(config) {
+	return config;
+}
+//#endregion
+export { defineConfig };

package/package.json

@@ -1,6 +1,21 @@
 {
   "name": "greenly",
-  "version": "0.0.1",
+  "version": "1.0.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",
+    "checks",
+    "ci",
+    "cli",
+    "format",
+    "lint",
+    "pr-checks",
+    "pre-commit",
+    "pre-push",
+    "task-runner",
+    "typecheck"
+  ],
+  "homepage": "https://github.com/yusifaliyevpro/greenly#readme",
   "bugs": {
     "url": "https://github.com/yusifaliyevpro/greenly/issues"
   },
@@ -24,7 +39,26 @@
       "url": "https://kofe.al/@yusifaliyevpro"
     }
   ],
+  "bin": {
+    "greenly": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
   "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
@@ -33,15 +67,24 @@
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
     "lint": "oxlint",
-    "lint:fix": "oxlint --fix"
+    "lint:fix": "oxlint --fix",
+    "check": "node dist/cli.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "start": "node dist/cli.js"
+  },
+  "dependencies": {
+    "@clack/prompts": "1.7.0",
+    "c12": "3.3.4"
   },
   "devDependencies": {
     "@types/node": "24.13.3",
     "oxfmt": "0.61.0",
     "oxlint": "1.76.0",
-    "oxlint-tsgolint": "^7.0.2001",
+    "oxlint-tsgolint": "7.0.2001",
     "tsdown": "0.22.14",
-    "typescript": "7.0.2"
+    "typescript": "7.0.2",
+    "vitest": "4.1.10"
   },
   "engines": {
     "node": ">=18"

package/.vscode/extensions.json

@@ -1,3 +0,0 @@
-{
-  "recommendations": ["oxc.oxc-vscode"]
-}

package/.vscode/settings.json

@@ -1,4 +0,0 @@
-{
-  "editor.defaultFormatter": "oxc.oxc-vscode",
-  "editor.formatOnSave": true
-}

package/oxfmt.config.ts

@@ -1,10 +0,0 @@
-import { defineConfig } from "oxfmt";
-
-export default defineConfig({
-  printWidth: 120,
-  singleQuote: false,
-  insertFinalNewline: true,
-  sortImports: {
-    newlinesBetween: false,
-  },
-});

package/oxlint.config.ts

@@ -1,19 +0,0 @@
-import { defineConfig } from "oxlint";
-
-export default defineConfig({
-  plugins: ["typescript", "unicorn", "import"],
-  categories: {
-    suspicious: "warn",
-  },
-  options: {
-    typeAware: true,
-    typeCheck: true,
-  },
-  ignorePatterns: ["dist"],
-  rules: {
-    eqeqeq: "warn",
-    "no-throw-literal": "warn",
-    "unicorn/prefer-node-protocol": "warn",
-    "typescript/consistent-type-imports": "warn",
-  },
-});

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2023",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "resolveJsonModule": true,
-    "strict": true,
-    "noUnusedLocals": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "noEmit": true,
-    "types": ["node"]
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsdown.config.ts

@@ -1,3 +0,0 @@
-import { defineConfig } from "tsdown";
-
-export default defineConfig({});