@chanom/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,383 @@
+#!/usr/bin/env node
+import { intro, log, multiselect, outro, select, spinner } from "@clack/prompts";
+import pc from "picocolors";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+//#region src/utils/detect-pm.ts
+const KNOWN_PMS = [
+	"pnpm",
+	"yarn",
+	"bun",
+	"npm"
+];
+function fromPkgJson(cwd) {
+	const pkgPath = join(cwd, "package.json");
+	if (!existsSync(pkgPath)) return void 0;
+	try {
+		const { packageManager } = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		if (!packageManager) return void 0;
+		const name = packageManager.split("@")[0];
+		return KNOWN_PMS.includes(name) ? name : void 0;
+	} catch {
+		return;
+	}
+}
+function fromUserAgent() {
+	const agent = process.env["npm_config_user_agent"];
+	if (!agent) return void 0;
+	return KNOWN_PMS.find((pm) => agent.startsWith(pm));
+}
+function detectPm(cwd = process.cwd(), defaultPm = "pnpm") {
+	return fromPkgJson(cwd) ?? fromUserAgent() ?? defaultPm;
+}
+//#endregion
+//#region src/utils/git.ts
+function run(args, cwd) {
+	const { status, stdout, stderr } = spawnSync("git", args, {
+		stdio: "pipe",
+		cwd,
+		encoding: "utf-8"
+	});
+	return {
+		ok: status === 0,
+		stdout: (stdout ?? "").trim(),
+		stderr: (stderr ?? "").trim()
+	};
+}
+function isGitRepo(cwd = process.cwd()) {
+	return existsSync(join(cwd, ".git"));
+}
+function init(cwd) {
+	return run(["init"], cwd);
+}
+/** True if git has a usable author identity (committer.name + committer.email). */
+function hasIdentity(cwd) {
+	return run(["var", "GIT_COMMITTER_IDENT"], cwd).ok;
+}
+/** Set a repo-local identity so commits succeed on a fresh repo without global config. */
+function setLocalIdentity(cwd, name, email) {
+	run([
+		"config",
+		"user.name",
+		name
+	], cwd);
+	run([
+		"config",
+		"user.email",
+		email
+	], cwd);
+}
+function stageAll(cwd) {
+	return run(["add", "."], cwd);
+}
+/** True if there is anything staged to commit. */
+function hasStagedChanges(cwd) {
+	return !run([
+		"diff",
+		"--cached",
+		"--quiet"
+	], cwd).ok;
+}
+function commit(cwd, message) {
+	return run([
+		"commit",
+		"-m",
+		message
+	], cwd);
+}
+function writeGitignore(cwd, contents = "node_modules\n") {
+	writeFileSync(join(cwd, ".gitignore"), contents, "utf-8");
+}
+//#endregion
+//#region src/utils/install.ts
+function installDev(pm, cwd, ...packages) {
+	spawnSync(pm, [
+		"add",
+		"-D",
+		...packages
+	], {
+		stdio: "inherit",
+		cwd
+	});
+}
+//#endregion
+//#region src/utils/pkg.ts
+function isEsm(pkg) {
+	return pkg.type === "module";
+}
+function readPkg(cwd) {
+	const pkgPath = join(cwd, "package.json");
+	return {
+		pkg: JSON.parse(readFileSync(pkgPath, "utf-8")),
+		pkgPath
+	};
+}
+function isPackageInstalled(pkg, name) {
+	return name in (pkg.dependencies ?? {}) || name in (pkg.devDependencies ?? {});
+}
+//#endregion
+//#region src/commands/add-commitlint/index.ts
+function getPackages$7(pkg) {
+	const missing = [];
+	if (!isPackageInstalled(pkg, "@commitlint/cli")) missing.push("@commitlint/cli");
+	if (!isPackageInstalled(pkg, "@commitlint/config-conventional")) missing.push("@commitlint/config-conventional");
+	return missing;
+}
+function apply$7(cwd) {
+	writeFileSync(join(cwd, ".commitlintrc.json"), JSON.stringify({ extends: ["@commitlint/config-conventional"] }, null, 2) + "\n");
+	if (existsSync(join(cwd, ".husky"))) writeFileSync(join(cwd, ".husky", "commit-msg"), "npx --no -- commitlint --edit $1\n");
+}
+//#endregion
+//#region src/commands/add-eslint/index.ts
+function getPackages$6(pkg) {
+	return isPackageInstalled(pkg, "eslint") ? [] : ["eslint"];
+}
+function apply$6(cwd, esm) {
+	writeFileSync(join(cwd, `eslint.config.${esm ? "ts" : "mts"}`), `export { default } from '@chanom/dev-config/eslint/config';\n`);
+	const { pkg, pkgPath } = readPkg(cwd);
+	pkg.scripts ??= {};
+	const missing = {};
+	if (!pkg.scripts["lint"]) missing["lint"] = "eslint .";
+	if (!pkg.scripts["lint:fix"]) missing["lint:fix"] = "eslint . --fix";
+	for (const [key, value] of Object.entries(missing)) pkg.scripts[key] = value;
+	const skipped = ["lint", "lint:fix"].filter((k) => !(k in missing));
+	for (const key of skipped) log.warn(`\`${key}\` script already exists in package.json - skipping`);
+	if (Object.keys(missing).length > 0) writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+//#endregion
+//#region src/commands/add-husky/index.ts
+const PM_EXEC = {
+	pnpm: ["pnpm", "exec"],
+	npm: ["npx"],
+	yarn: ["yarn"],
+	bun: ["bunx"]
+};
+function getPackages$5(pkg) {
+	return isPackageInstalled(pkg, "husky") ? [] : ["husky"];
+}
+function apply$5(cwd, pm) {
+	const [cmd, ...args] = PM_EXEC[pm];
+	spawnSync(cmd, [
+		...args,
+		"husky",
+		"init"
+	], {
+		stdio: "inherit",
+		cwd
+	});
+}
+//#endregion
+//#region src/commands/add-knip/index.ts
+function getPackages$4(pkg) {
+	return isPackageInstalled(pkg, "knip") ? [] : ["knip"];
+}
+function apply$4(cwd) {
+	writeFileSync(join(cwd, "knip.json"), JSON.stringify({ entry: ["src/index.ts"] }, null, 2) + "\n");
+	const { pkg, pkgPath } = readPkg(cwd);
+	pkg.scripts ??= {};
+	if (pkg.scripts["knip"]) log.warn("`knip` script already exists in package.json - skipping");
+	else {
+		pkg.scripts["knip"] = "knip";
+		writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+	}
+}
+//#endregion
+//#region src/commands/add-lint-staged/index.ts
+function getPackages$3(pkg) {
+	return isPackageInstalled(pkg, "lint-staged") ? [] : ["lint-staged"];
+}
+function apply$3(cwd, linters = [], formatters = []) {
+	const config = {};
+	const jsGlob = "**/*.{js,jsx,ts,tsx,mjs,cjs,mts,cts}";
+	if (linters.includes("oxlint")) {
+		config[jsGlob] ??= [];
+		config[jsGlob].push("oxlint --fix");
+	}
+	if (linters.includes("eslint")) {
+		config[jsGlob] ??= [];
+		config[jsGlob].push("eslint --fix");
+	}
+	if (formatters.includes("oxfmt")) {
+		config["*"] ??= [];
+		config["*"].push("oxfmt");
+	}
+	if (formatters.includes("prettier")) {
+		config["*"] ??= [];
+		config["*"].push("prettier --ignore-unknown --write");
+	}
+	writeFileSync(join(cwd, ".lintstagedrc.json"), JSON.stringify(config, null, 2) + "\n");
+	if (existsSync(join(cwd, ".husky"))) writeFileSync(join(cwd, ".husky", "pre-commit"), "lint-staged\n");
+}
+//#endregion
+//#region src/commands/add-oxfmt/logic.ts
+function getMissingScripts$1(scripts) {
+	const missing = {};
+	if (!scripts["format"]) missing["format"] = "oxfmt";
+	if (!scripts["format:check"]) missing["format:check"] = "oxfmt --check";
+	return missing;
+}
+//#endregion
+//#region src/commands/add-oxfmt/index.ts
+function getPackages$2(pkg) {
+	return isPackageInstalled(pkg, "oxfmt") ? [] : [`oxfmt@0.56.0`, "@chanom/dev-config"];
+}
+function apply$2(cwd, esm) {
+	writeFileSync(join(cwd, `oxfmt.config.${esm ? "ts" : "mts"}`), `export { default } from '@chanom/dev-config/oxfmt/config';\n`);
+	const { pkg, pkgPath } = readPkg(cwd);
+	pkg.scripts ??= {};
+	const missing = getMissingScripts$1(pkg.scripts);
+	for (const [key, value] of Object.entries(missing)) pkg.scripts[key] = value;
+	const skipped = ["format", "format:check"].filter((k) => !(k in missing));
+	for (const key of skipped) log.warn(`\`${key}\` script already exists in package.json - skipping`);
+	if (Object.keys(missing).length > 0) writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+//#endregion
+//#region src/commands/add-oxlint/logic.ts
+function getMissingScripts(scripts) {
+	const missing = {};
+	if (!scripts["lint"]) missing["lint"] = "oxlint";
+	if (!scripts["lint:fix"]) missing["lint:fix"] = "oxlint --fix";
+	return missing;
+}
+//#endregion
+//#region src/commands/add-oxlint/index.ts
+function getPackages$1(pkg) {
+	return isPackageInstalled(pkg, "oxlint") ? [] : [`oxlint@1.71.0`, "@chanom/dev-config"];
+}
+function apply$1(cwd, esm) {
+	writeFileSync(join(cwd, `oxlint.config.${esm ? "ts" : "mts"}`), `export { default } from '@chanom/dev-config/oxlint/config';\n`);
+	const { pkg, pkgPath } = readPkg(cwd);
+	pkg.scripts ??= {};
+	const missing = getMissingScripts(pkg.scripts);
+	for (const [key, value] of Object.entries(missing)) pkg.scripts[key] = value;
+	const skipped = ["lint", "lint:fix"].filter((k) => !(k in missing));
+	for (const key of skipped) log.warn(`\`${key}\` script already exists in package.json - skipping`);
+	if (Object.keys(missing).length > 0) writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+//#endregion
+//#region src/commands/add-prettier/index.ts
+function getPackages(pkg) {
+	return isPackageInstalled(pkg, "prettier") ? [] : ["prettier"];
+}
+function apply(cwd) {
+	writeFileSync(join(cwd, ".prettierrc"), JSON.stringify({}, null, 2) + "\n");
+	const { pkg, pkgPath } = readPkg(cwd);
+	pkg.scripts ??= {};
+	const missing = {};
+	if (!pkg.scripts["format"]) missing["format"] = "prettier --write .";
+	if (!pkg.scripts["format:check"]) missing["format:check"] = "prettier --check .";
+	for (const [key, value] of Object.entries(missing)) pkg.scripts[key] = value;
+	const skipped = ["format", "format:check"].filter((k) => !(k in missing));
+	for (const key of skipped) log.warn(`\`${key}\` script already exists in package.json - skipping`);
+	if (Object.keys(missing).length > 0) writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
+}
+//#endregion
+//#region src/commands/brew/index.ts
+async function brew(cwd = process.cwd()) {
+	intro(pc.magenta("🧋 Chanom - Let's brew your project!"));
+	if (!isGitRepo(cwd)) {
+		const s = spinner();
+		s.start("Git not found, initializing repository...");
+		init(cwd);
+		writeGitignore(cwd);
+		s.stop("Git initialized");
+	}
+	const pm = detectPm(cwd);
+	const toppings = await multiselect({
+		message: "Which toppings would you like?",
+		options: [
+			{
+				value: "oxlint",
+				label: "oxlint",
+				hint: "fast Rust-based linter"
+			},
+			{
+				value: "oxfmt",
+				label: "oxfmt",
+				hint: "fast Rust-based formatter"
+			},
+			{
+				value: "eslint",
+				label: "eslint",
+				hint: "stub config"
+			},
+			{
+				value: "prettier",
+				label: "prettier",
+				hint: "stub config"
+			},
+			{
+				value: "knip",
+				label: "knip",
+				hint: "stub config"
+			}
+		],
+		required: false
+	});
+	if (typeof toppings === "symbol") process.exit(0);
+	const sweetness = await select({
+		message: "How sweet would you like it?",
+		options: [{
+			value: "light",
+			label: "light",
+			hint: "warn only, no blocking"
+		}, {
+			value: "medium",
+			label: "medium",
+			hint: "block on commit (husky + lint-staged + commitlint)"
+		}]
+	});
+	if (typeof sweetness === "symbol") process.exit(0);
+	const { pkg } = readPkg(cwd);
+	const esm = isEsm(pkg);
+	const packages = [];
+	if (toppings.includes("oxlint")) packages.push(...getPackages$1(pkg));
+	if (toppings.includes("oxfmt")) packages.push(...getPackages$2(pkg));
+	if (toppings.includes("eslint")) packages.push(...getPackages$6(pkg));
+	if (toppings.includes("prettier")) packages.push(...getPackages(pkg));
+	if (toppings.includes("knip")) packages.push(...getPackages$4(pkg));
+	if (sweetness === "medium") packages.push(...getPackages$5(pkg), ...getPackages$3(pkg), ...getPackages$7(pkg));
+	if (packages.length > 0) {
+		const s = spinner();
+		const uniquePackages = Array.from(new Set(packages));
+		s.start(`Installing ${uniquePackages.join(", ")}...`);
+		installDev(pm, cwd, ...uniquePackages);
+		s.stop("Packages installed");
+	}
+	if (toppings.includes("oxlint")) apply$1(cwd, esm);
+	if (toppings.includes("oxfmt")) apply$2(cwd, esm);
+	if (toppings.includes("eslint")) apply$6(cwd, esm);
+	if (toppings.includes("prettier")) apply(cwd);
+	if (toppings.includes("knip")) apply$4(cwd);
+	if (sweetness === "medium") {
+		apply$5(cwd, pm);
+		apply$3(cwd, toppings.filter((t) => ["oxlint", "eslint"].includes(t)), toppings.filter((t) => ["oxfmt", "prettier"].includes(t)));
+		apply$7(cwd);
+	}
+	const s2 = spinner();
+	s2.start("Committing changes...");
+	if (!hasIdentity(cwd)) setLocalIdentity(cwd, "Chanom", "chanom@local");
+	stageAll(cwd);
+	if (hasStagedChanges(cwd)) {
+		const result = commit(cwd, "chore: setup chanom configuration");
+		if (result.ok) s2.stop("Changes committed");
+		else {
+			s2.stop(pc.yellow("Could not commit changes automatically"));
+			const detail = result.stderr || result.stdout;
+			log.warn(`${detail ? detail + "\n" : ""}Your files are staged - commit them manually when ready.`);
+		}
+	} else s2.stop("Nothing to commit, skipping");
+	outro(pc.green(`Your Chanom with ${toppings.join(", ")} toppings and ${sweetness} sweetness is ready! Enjoy! 🧋`));
+}
+//#endregion
+//#region src/index.ts
+const command = process.argv[2];
+if (command === "brew") await brew();
+else {
+	console.error(`Unknown command: ${command ?? "(none)"}`);
+	console.error("Usage: chanom brew");
+	process.exit(1);
+}
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@chanom/cli",
+  "version": "0.0.1",
+  "description": "",
+  "keywords": [],
+  "type": "module",
+  "bin": {
+    "chanom": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@clack/prompts": "1.6.0",
+    "picocolors": "1.1.1"
+  },
+  "devDependencies": {
+    "@tsconfig/node-lts": "24.0.0",
+    "@tsconfig/node-ts": "23.6.4",
+    "@types/node": "26.0.1",
+    "tsdown": "0.22.3",
+    "typescript": "6.0.3",
+    "@chanom/dev-config": "0.0.2"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch"
+  }
+}