@varlock/bumpy 0.0.0 → 0.0.2

package/dist/logger-C2dEe5Su.mjs

@@ -0,0 +1,135 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region ../../node_modules/.bun/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}));
+//#endregion
+//#region src/utils/logger.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+const log = {
+	info(msg) {
+		console.log(`${import_picocolors.default.blue("info")} ${msg}`);
+	},
+	success(msg) {
+		console.log(`${import_picocolors.default.green("done")} ${msg}`);
+	},
+	warn(msg) {
+		console.log(`${import_picocolors.default.yellow("warn")} ${msg}`);
+	},
+	error(msg) {
+		console.error(`${import_picocolors.default.red("error")} ${msg}`);
+	},
+	step(msg) {
+		console.log(`${import_picocolors.default.cyan("=>")} ${msg}`);
+	},
+	dim(msg) {
+		console.log(import_picocolors.default.dim(msg));
+	},
+	bold(msg) {
+		console.log(import_picocolors.default.bold(msg));
+	},
+	table(rows) {
+		if (rows.length === 0) return;
+		const colWidths = rows[0].map((_, i) => Math.max(...rows.map((r) => (r[i] ?? "").length)));
+		for (const row of rows) console.log(row.map((cell, i) => cell.padEnd(colWidths[i])).join("  "));
+	}
+};
+function colorize(text, color) {
+	return import_picocolors.default[color](text);
+}
+//#endregion
+export { __exportAll as a, __commonJSMin as i, log as n, __toESM as o, require_picocolors as r, colorize as t };

package/dist/migrate-CfQNwD0T.mjs

@@ -0,0 +1,121 @@
+import { n as log, o as __toESM, r as require_picocolors } from "./logger-C2dEe5Su.mjs";
+import { a as readJson, n as exists, o as readText } from "./fs-0AtnPUUe.mjs";
+import { r as getBumpyDir } from "./config-BkwIEaQg.mjs";
+import { i as writeChangeset } from "./changeset-UCZdSRDv.mjs";
+import { a as fe, c as ot, n as O, o as gt, s as mt, t as unwrap } from "./clack-CDRCHrC-.mjs";
+import { initCommand } from "./init-B0q3wEQW.mjs";
+import { resolve } from "node:path";
+import { readdir } from "node:fs/promises";
+//#region src/commands/migrate.ts
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+async function migrateCommand(rootDir, opts) {
+	const changesetDir = resolve(rootDir, ".changeset");
+	if (!await exists(changesetDir)) {
+		log.error("No .changeset/ directory found. Nothing to migrate.");
+		process.exit(1);
+	}
+	const bumpyDir = getBumpyDir(rootDir);
+	if (!await exists(resolve(bumpyDir, "_config.json"))) {
+		log.step("Initializing .bumpy/ directory...");
+		await initCommand(rootDir);
+	}
+	const changesetConfigPath = resolve(changesetDir, "config.json");
+	if (await exists(changesetConfigPath)) {
+		log.step("Migrating config from .changeset/config.json...");
+		await migrateConfig(changesetConfigPath, bumpyDir);
+	}
+	const mdFiles = (await readdir(changesetDir)).filter((f) => f.endsWith(".md") && f !== "README.md");
+	if (mdFiles.length > 0) {
+		log.step(`Migrating ${mdFiles.length} pending changeset(s)...`);
+		let migrated = 0;
+		for (const file of mdFiles) {
+			const result = parseChangesetFile(await readText(resolve(changesetDir, file)));
+			if (!result) {
+				log.warn(`  Skipped ${file} (could not parse)`);
+				continue;
+			}
+			const name = file.replace(/\.md$/, "");
+			if (await exists(resolve(bumpyDir, file))) {
+				log.dim(`  Skipped ${file} (already exists in .bumpy/)`);
+				continue;
+			}
+			await writeChangeset(rootDir, name, result.releases, result.summary);
+			migrated++;
+			log.dim(`  Migrated ${file}`);
+		}
+		log.success(`Migrated ${migrated} changeset(s)`);
+	} else log.info("No pending changesets to migrate.");
+	if (!opts.force) {
+		mt(import_picocolors.default.bgCyan(import_picocolors.default.black(" bumpy migrate ")));
+		if (unwrap(await ot({
+			message: "Remove .changeset/ directory?",
+			initialValue: false
+		}))) {
+			const spin = fe();
+			spin.start("Removing .changeset/");
+			const { rm } = await import("node:fs/promises");
+			await rm(changesetDir, { recursive: true });
+			spin.stop("Removed .changeset/ directory");
+		} else O.info("Keeping .changeset/ — you can remove it manually when ready.");
+		gt(import_picocolors.default.green("Cleanup complete"));
+	}
+	console.log();
+	log.success("Migration complete!");
+	log.dim("Review .bumpy/_config.json and adjust settings as needed.");
+	log.dim("Key differences from changesets:");
+	log.dim("  - peerDependency bumps only propagate on major (not minor)");
+	log.dim("  - Use 'patch-isolated'/'minor-isolated' to skip propagation");
+	log.dim("  - Per-package config goes in package.json[\"bumpy\"]");
+}
+async function migrateConfig(changesetConfigPath, bumpyDir) {
+	const csConfig = await readJson(changesetConfigPath);
+	const bumpyConfigPath = resolve(bumpyDir, "_config.json");
+	let bumpyConfig = {};
+	if (await exists(bumpyConfigPath)) bumpyConfig = await readJson(bumpyConfigPath);
+	for (const field of [
+		"baseBranch",
+		"access",
+		"commit",
+		"fixed",
+		"linked",
+		"ignore",
+		"updateInternalDependencies",
+		"privatePackages"
+	]) if (csConfig[field] !== void 0) bumpyConfig[field] = csConfig[field];
+	const { writeJson } = await import("./fs-0AtnPUUe.mjs").then((n) => n.r);
+	await writeJson(bumpyConfigPath, bumpyConfig);
+	log.dim("  Migrated config fields: " + Object.keys(bumpyConfig).filter((k) => k !== "baseBranch" || bumpyConfig[k] !== "main").join(", "));
+}
+/** Parse a changesets-format markdown file */
+function parseChangesetFile(content) {
+	const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+	if (!match) return null;
+	const frontmatter = match[1].trim();
+	const summary = match[2].trim();
+	if (!frontmatter) return null;
+	const releases = [];
+	for (const line of frontmatter.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const lineMatch = trimmed.match(/^"?([^"]+)"?\s*:\s*(.+)$/);
+		if (!lineMatch) continue;
+		const name = lineMatch[1].trim();
+		const type = lineMatch[2].trim();
+		if (type === "none") continue;
+		if ([
+			"major",
+			"minor",
+			"patch"
+		].includes(type)) releases.push({
+			name,
+			type
+		});
+	}
+	if (releases.length === 0 && !summary) return null;
+	return {
+		releases,
+		summary
+	};
+}
+//#endregion
+export { migrateCommand };

package/dist/names-Ck8cun7B.mjs

@@ -0,0 +1,144 @@
+//#region src/utils/names.ts
+/** Generate a random adjective-noun name for changeset files */
+function randomName() {
+	const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
+	return `${pick(ADJECTIVES)}-${pick(ADJECTIVES)}-${pick(NOUNS)}`;
+}
+/** Sanitize a user-provided name into a valid filename slug */
+function slugify(name) {
+	return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+const ADJECTIVES = [
+	"brave",
+	"calm",
+	"dark",
+	"eager",
+	"fair",
+	"gentle",
+	"happy",
+	"icy",
+	"jolly",
+	"keen",
+	"lively",
+	"merry",
+	"neat",
+	"odd",
+	"proud",
+	"quiet",
+	"rare",
+	"shy",
+	"tall",
+	"warm",
+	"young",
+	"bold",
+	"cool",
+	"dry",
+	"fast",
+	"glad",
+	"huge",
+	"kind",
+	"lazy",
+	"mild",
+	"new",
+	"old",
+	"pink",
+	"red",
+	"safe",
+	"thin",
+	"vast",
+	"wide",
+	"witty",
+	"zany",
+	"bright",
+	"clean",
+	"deep",
+	"fresh",
+	"grand",
+	"light",
+	"pure",
+	"rich",
+	"sharp",
+	"smooth",
+	"soft",
+	"swift",
+	"tough",
+	"wild",
+	"wise",
+	"tidy",
+	"silver",
+	"golden",
+	"copper",
+	"amber",
+	"coral",
+	"jade",
+	"violet",
+	"rusty"
+];
+const NOUNS = [
+	"ant",
+	"bee",
+	"cat",
+	"dog",
+	"elk",
+	"fox",
+	"gnu",
+	"hen",
+	"ibis",
+	"jay",
+	"koi",
+	"lark",
+	"moth",
+	"newt",
+	"owl",
+	"pug",
+	"quail",
+	"ram",
+	"seal",
+	"toad",
+	"urchin",
+	"vole",
+	"wasp",
+	"yak",
+	"bass",
+	"clam",
+	"dove",
+	"eel",
+	"frog",
+	"goat",
+	"hawk",
+	"igloo",
+	"jade",
+	"kite",
+	"lake",
+	"moon",
+	"nest",
+	"oak",
+	"pine",
+	"reef",
+	"star",
+	"tree",
+	"wave",
+	"fern",
+	"lily",
+	"rose",
+	"sage",
+	"vine",
+	"dawn",
+	"dusk",
+	"mist",
+	"rain",
+	"snow",
+	"wind",
+	"glow",
+	"haze",
+	"crab",
+	"deer",
+	"finch",
+	"heron",
+	"crane",
+	"robin",
+	"swift",
+	"trout"
+];
+//#endregion
+export { slugify as n, randomName as t };

package/dist/package-manager-DcI5TdDE.mjs

@@ -0,0 +1,80 @@
+import { a as readJson, n as exists, o as readText } from "./fs-0AtnPUUe.mjs";
+import { t as jsYaml } from "./js-yaml-DpZfOoD4.mjs";
+import { resolve } from "node:path";
+//#region src/utils/package-manager.ts
+/** Detect the package manager, extract workspace globs, and load catalogs */
+async function detectWorkspaces(rootDir) {
+	const pm = await detectPackageManager(rootDir);
+	return {
+		packageManager: pm,
+		globs: await getWorkspaceGlobs(rootDir, pm),
+		catalogs: await loadCatalogs(rootDir, pm)
+	};
+}
+async function detectPackageManager(rootDir) {
+	if (await exists(resolve(rootDir, "bun.lock")) || await exists(resolve(rootDir, "bun.lockb"))) return "bun";
+	if (await exists(resolve(rootDir, "pnpm-lock.yaml"))) return "pnpm";
+	if (await exists(resolve(rootDir, "yarn.lock"))) return "yarn";
+	try {
+		const pkg = await readJson(resolve(rootDir, "package.json"));
+		if (typeof pkg.packageManager === "string") {
+			const name = pkg.packageManager.split("@")[0];
+			if (name === "pnpm" || name === "yarn" || name === "bun") return name;
+		}
+	} catch {}
+	return "npm";
+}
+async function getWorkspaceGlobs(rootDir, pm) {
+	if (pm === "pnpm") {
+		const wsFile = resolve(rootDir, "pnpm-workspace.yaml");
+		if (await exists(wsFile)) {
+			const content = await readText(wsFile);
+			const parsed = jsYaml.load(content);
+			if (parsed?.packages) return parsed.packages;
+		}
+	}
+	try {
+		const workspaces = (await readJson(resolve(rootDir, "package.json"))).workspaces;
+		if (Array.isArray(workspaces)) return workspaces;
+		if (workspaces && typeof workspaces === "object" && "packages" in workspaces) {
+			const pkgs = workspaces.packages;
+			if (Array.isArray(pkgs)) return pkgs;
+		}
+	} catch {}
+	return [];
+}
+/** Load catalog definitions from pnpm-workspace.yaml or root package.json */
+async function loadCatalogs(rootDir, pm) {
+	const catalogs = /* @__PURE__ */ new Map();
+	if (pm === "pnpm") {
+		const wsFile = resolve(rootDir, "pnpm-workspace.yaml");
+		if (await exists(wsFile)) {
+			const content = await readText(wsFile);
+			const parsed = jsYaml.load(content);
+			if (parsed?.catalog) catalogs.set("", parsed.catalog);
+			if (parsed?.catalogs) for (const [name, deps] of Object.entries(parsed.catalogs)) catalogs.set(name, deps);
+		}
+	}
+	try {
+		const pkg = await readJson(resolve(rootDir, "package.json"));
+		if (pkg.catalog && typeof pkg.catalog === "object") catalogs.set("", pkg.catalog);
+		if (pkg.catalogs && typeof pkg.catalogs === "object") for (const [name, deps] of Object.entries(pkg.catalogs)) catalogs.set(name, deps);
+		const workspaces = pkg.workspaces;
+		if (workspaces && typeof workspaces === "object" && !Array.isArray(workspaces)) {
+			const ws = workspaces;
+			if (ws.catalog && typeof ws.catalog === "object") catalogs.set("", ws.catalog);
+			if (ws.catalogs && typeof ws.catalogs === "object") for (const [name, deps] of Object.entries(ws.catalogs)) catalogs.set(name, deps);
+		}
+	} catch {}
+	return catalogs;
+}
+/** Resolve a specific dependency's catalog: reference */
+function resolveCatalogDep(depName, range, catalogs) {
+	if (!range.startsWith("catalog:")) return null;
+	const catalogName = range.slice(8).trim() || "";
+	const catalog = catalogs.get(catalogName);
+	if (!catalog) return null;
+	return catalog[depName] ?? null;
+}
+//#endregion
+export { detectWorkspaces as n, resolveCatalogDep as r, detectPackageManager as t };