@varlock/bumpy 0.0.0 → 0.0.2

package/dist/cli.d.mts

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

package/dist/cli.mjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+import { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
+import { n as findRoot } from "./config-BkwIEaQg.mjs";
+//#region src/cli.ts
+const args = process.argv.slice(2);
+const command = args[0];
+function parseFlags(args) {
+	const flags = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg.startsWith("--")) {
+			const key = arg.slice(2);
+			const next = args[i + 1];
+			if (next && !next.startsWith("--")) {
+				flags[key] = next;
+				i++;
+			} else flags[key] = true;
+		}
+	}
+	return flags;
+}
+async function main() {
+	const flags = parseFlags(args.slice(1));
+	try {
+		switch (command) {
+			case "init": {
+				const rootDir = await findRoot();
+				const { initCommand } = await import("./init-B0q3wEQW.mjs");
+				await initCommand(rootDir);
+				break;
+			}
+			case "add": {
+				const rootDir = await findRoot();
+				const { addCommand } = await import("./add-BjyVIUlr.mjs");
+				await addCommand(rootDir, {
+					packages: flags.packages,
+					message: flags.message,
+					name: flags.name,
+					empty: flags.empty === true
+				});
+				break;
+			}
+			case "status": {
+				const rootDir = await findRoot();
+				const { statusCommand } = await import("./status--Q8yAxQ4.mjs");
+				await statusCommand(rootDir, {
+					json: flags.json === true,
+					packagesOnly: flags.packages === true,
+					bumpType: flags.bump,
+					filter: flags.filter,
+					verbose: flags.verbose === true
+				});
+				break;
+			}
+			case "version": {
+				const rootDir = await findRoot();
+				const { versionCommand } = await import("./version-cAUkfYPx.mjs");
+				await versionCommand(rootDir);
+				break;
+			}
+			case "generate": {
+				const rootDir = await findRoot();
+				const { generateCommand } = await import("./generate-Btrsn1qi.mjs");
+				await generateCommand(rootDir, {
+					from: flags.from,
+					dryRun: flags["dry-run"] === true,
+					name: flags.name
+				});
+				break;
+			}
+			case "migrate": {
+				const rootDir = await findRoot();
+				const { migrateCommand } = await import("./migrate-CfQNwD0T.mjs");
+				await migrateCommand(rootDir, { force: flags.force === true });
+				break;
+			}
+			case "check": {
+				const rootDir = await findRoot();
+				const { checkCommand } = await import("./check-jIwike9F.mjs");
+				await checkCommand(rootDir);
+				break;
+			}
+			case "ci": {
+				const rootDir = await findRoot();
+				const subcommand = args[1];
+				const ciFlags = parseFlags(args.slice(2));
+				if (subcommand === "check") {
+					const { ciCheckCommand } = await import("./ci-D6LQbR38.mjs");
+					await ciCheckCommand(rootDir, {
+						comment: ciFlags.comment !== void 0 ? ciFlags.comment === true : void 0,
+						failOnMissing: ciFlags["fail-on-missing"] === true
+					});
+				} else if (subcommand === "release") {
+					const { ciReleaseCommand } = await import("./ci-D6LQbR38.mjs");
+					await ciReleaseCommand(rootDir, {
+						mode: ciFlags["auto-publish"] === true ? "auto-publish" : "version-pr",
+						tag: ciFlags.tag,
+						branch: ciFlags.branch
+					});
+				} else if (subcommand === "setup") {
+					const { ciSetupCommand } = await import("./ci-setup-C6FlOfW5.mjs");
+					await ciSetupCommand(rootDir);
+				} else {
+					log.error(`Unknown ci subcommand: ${subcommand}. Use "ci check", "ci release", or "ci setup".`);
+					process.exit(1);
+				}
+				break;
+			}
+			case "publish": {
+				const rootDir = await findRoot();
+				const { publishCommand } = await import("./publish-D_7RqEYL.mjs");
+				await publishCommand(rootDir, {
+					dryRun: flags["dry-run"] === true,
+					tag: flags.tag,
+					noPush: flags["no-push"] === true,
+					filter: flags.filter
+				});
+				break;
+			}
+			case "ai": {
+				const rootDir = await findRoot();
+				const subcommand = args[1];
+				const aiFlags = parseFlags(args.slice(2));
+				if (subcommand === "setup") {
+					const { aiSetupCommand } = await import("./ai-CQhUyHAG.mjs");
+					await aiSetupCommand(rootDir, { target: aiFlags.target });
+				} else {
+					log.error(`Unknown ai subcommand: ${subcommand}. Use "ai setup".`);
+					process.exit(1);
+				}
+				break;
+			}
+			case "--version":
+			case "-v":
+				console.log(`bumpy 0.0.2`);
+				break;
+			case "help":
+			case "--help":
+			case "-h":
+			case void 0:
+				printHelp();
+				break;
+			default:
+				log.error(`Unknown command: ${command}`);
+				printHelp();
+				process.exit(1);
+		}
+	} catch (err) {
+		log.error(err instanceof Error ? err.message : String(err));
+		process.exit(1);
+	}
+}
+function printHelp() {
+	console.log(`
+  ${colorize(`🐸 bumpy v0.0.2`, "bold")} - Modern monorepo versioning
+
+  Usage: bumpy <command> [options]
+
+  Commands:
+    init                    Initialize .bumpy/ directory
+    add                     Create a new changeset
+    generate                Generate changeset from conventional commits
+    status                  Show pending releases
+    check                   Verify changed packages have changesets (for pre-push hooks)
+    version                 Apply changesets and bump versions
+    publish                 Publish versioned packages
+    ci check                PR check — report pending releases, comment on PR
+    ci release              Release — create version PR or auto-publish
+    ci setup                Set up a token for triggering CI on version PRs
+    migrate                 Migrate from .changeset/ to .bumpy/
+    ai setup                Install AI skill for creating changesets
+
+  Add options:
+    --packages <list>       Package bumps (e.g., "pkg-a:minor,pkg-b:patch")
+    --message <text>        Changeset summary
+    --name <name>           Changeset filename
+    --empty                 Create an empty changeset
+
+  Generate options:
+    --from <ref>            Git ref to scan from (default: last version tag)
+    --dry-run               Preview without creating a changeset
+    --name <name>           Changeset filename
+
+  Status options:
+    --json                  Output as JSON (includes dirs, changesets, packageNames)
+    --packages              Output only package names, one per line
+    --bump <types>          Filter by bump type (e.g., "major", "minor,patch")
+    --filter <names>        Filter by package name/glob (e.g., "@myorg/*")
+    --verbose               Show changeset details
+
+  Publish options:
+    --dry-run               Preview without publishing
+    --tag <tag>             npm dist-tag (e.g., "next", "beta")
+    --no-push               Skip pushing git tags to remote
+    --filter <names>        Publish only matching packages (e.g., "@myorg/*")
+
+  CI check options:
+    --comment               Force PR comment on/off (auto-detected in CI)
+    --fail-on-missing       Exit 1 if no changesets found
+
+  CI release options:
+    --auto-publish          Version + publish directly (default: create version PR)
+    --tag <tag>             npm dist-tag for auto-publish
+    --branch <name>         Branch name for version PR (default: bumpy/version-packages)
+
+  AI setup options:
+    --target <tool>         Target AI tool: opencode, cursor, codex
+
+  ${colorize("https://github.com/dmno-dev/bumpy", "dim")}
+`);
+}
+main();
+//#endregion
+export {};

package/dist/config-BkwIEaQg.mjs

@@ -0,0 +1,215 @@
+import { a as __exportAll } from "./logger-C2dEe5Su.mjs";
+import { a as readJson, n as exists } from "./fs-0AtnPUUe.mjs";
+import { resolve } from "node:path";
+//#region src/types.ts
+const BUMP_LEVELS = {
+	patch: 0,
+	minor: 1,
+	major: 2
+};
+function bumpLevel(type) {
+	return BUMP_LEVELS[type];
+}
+function parseIsolatedBump(type) {
+	if (type.endsWith("-isolated")) return {
+		bump: type.replace("-isolated", ""),
+		isolated: true
+	};
+	return {
+		bump: type,
+		isolated: false
+	};
+}
+function maxBump(a, b) {
+	if (!a) return b;
+	return bumpLevel(a) >= bumpLevel(b) ? a : b;
+}
+const DEFAULT_BUMP_RULES = {
+	dependencies: {
+		trigger: "patch",
+		bumpAs: "patch"
+	},
+	peerDependencies: {
+		trigger: "major",
+		bumpAs: "major"
+	},
+	devDependencies: {
+		trigger: "none",
+		bumpAs: "patch"
+	},
+	optionalDependencies: {
+		trigger: "minor",
+		bumpAs: "patch"
+	}
+};
+const DEP_TYPES = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+const DEFAULT_PUBLISH_CONFIG = {
+	packManager: "auto",
+	publishManager: "npm",
+	publishArgs: [],
+	protocolResolution: "pack"
+};
+const DEFAULT_CONFIG = {
+	baseBranch: "main",
+	access: "public",
+	commit: false,
+	changelog: "default",
+	fixed: [],
+	linked: [],
+	ignore: [],
+	include: [],
+	updateInternalDependencies: "out-of-range",
+	dependencyBumpRules: {},
+	privatePackages: {
+		version: false,
+		tag: false
+	},
+	packages: {},
+	publish: { ...DEFAULT_PUBLISH_CONFIG },
+	aggregateRelease: false,
+	gitUser: {
+		name: "bumpy-bot",
+		email: "276066384+bumpy-bot@users.noreply.github.com"
+	},
+	versionPr: {
+		title: "🐸 Versioned release",
+		branch: "bumpy/version-packages",
+		preamble: [
+			`<a href="https://github.com/dmno-dev/bumpy"><img src="https://raw.githubusercontent.com/dmno-dev/bumpy/main/images/frog-talking.png" alt="bumpy-frog" width="60" align="left" style="image-rendering: pixelated;" title="Hi! I'm bumpy!" /></a>`,
+			"",
+			`This PR was created and will be kept in sync by [bumpy](https://github.com/dmno-dev/bumpy) based on your .bumpy changeset files. Merge it when you are ready to release the packages listed below:`,
+			"<br clear=\"left\" />"
+		].join("\n")
+	}
+};
+function hasCascade(r) {
+	return "cascade" in r && Object.keys(r.cascade).length > 0;
+}
+//#endregion
+//#region src/core/config.ts
+var config_exports = /* @__PURE__ */ __exportAll({
+	findRoot: () => findRoot,
+	getBumpyDir: () => getBumpyDir,
+	isPackageManaged: () => isPackageManaged,
+	loadConfig: () => loadConfig,
+	loadPackageConfig: () => loadPackageConfig,
+	matchGlob: () => matchGlob
+});
+const BUMPY_DIR = ".bumpy";
+const CONFIG_FILE = "_config.json";
+/** Find the monorepo root by walking up from cwd looking for .bumpy/ */
+async function findRoot(startDir = process.cwd()) {
+	let dir = resolve(startDir);
+	while (true) {
+		if (await exists(resolve(dir, BUMPY_DIR))) return dir;
+		if (await exists(resolve(dir, "package.json"))) try {
+			if ((await readJson(resolve(dir, "package.json"))).workspaces) return dir;
+		} catch {}
+		const parent = resolve(dir, "..");
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return resolve(startDir);
+}
+/** Load the root bumpy config, merging with defaults */
+async function loadConfig(rootDir) {
+	const configPath = resolve(rootDir, BUMPY_DIR, CONFIG_FILE);
+	let userConfig = {};
+	if (await exists(configPath)) userConfig = await readJson(configPath);
+	return mergeConfig(DEFAULT_CONFIG, userConfig);
+}
+/** Load per-package bumpy config from package.json["bumpy"] or .bumpy.config.json */
+async function loadPackageConfig(pkgDir, rootConfig, pkgName) {
+	const rootPkgConfig = findPackageConfig(rootConfig, pkgName);
+	let pkgJsonConfig = {};
+	try {
+		const pkg = await readJson(resolve(pkgDir, "package.json"));
+		if (pkg.bumpy && typeof pkg.bumpy === "object") pkgJsonConfig = pkg.bumpy;
+	} catch {}
+	return mergePackageConfig(rootPkgConfig, pkgJsonConfig);
+}
+/** Find a package config from the root config, supporting glob patterns */
+function findPackageConfig(config, pkgName) {
+	if (config.packages[pkgName]) return config.packages[pkgName];
+	for (const [pattern, pkgConfig] of Object.entries(config.packages)) if (matchGlob(pkgName, pattern)) return pkgConfig;
+	return {};
+}
+/** Simple glob matching for package names (supports * and **) */
+function matchGlob(name, pattern) {
+	if (name === pattern) return true;
+	const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{DOUBLE}}").replace(/\*/g, "[^/]*").replace(/{{DOUBLE}}/g, ".*");
+	return new RegExp(`^${regexStr}$`).test(name);
+}
+function mergeConfig(defaults, user) {
+	return {
+		...defaults,
+		...user,
+		dependencyBumpRules: {
+			...defaults.dependencyBumpRules,
+			...user.dependencyBumpRules
+		},
+		privatePackages: {
+			...defaults.privatePackages,
+			...user.privatePackages
+		},
+		publish: {
+			...defaults.publish,
+			...user.publish
+		},
+		packages: {
+			...defaults.packages,
+			...user.packages
+		}
+	};
+}
+function mergePackageConfig(...configs) {
+	const result = {};
+	for (const cfg of configs) {
+		Object.assign(result, cfg);
+		if (cfg.dependencyBumpRules) result.dependencyBumpRules = {
+			...result.dependencyBumpRules,
+			...cfg.dependencyBumpRules
+		};
+		if (cfg.specificDependencyRules) result.specificDependencyRules = {
+			...result.specificDependencyRules,
+			...cfg.specificDependencyRules
+		};
+		if (cfg.cascadeTo) result.cascadeTo = {
+			...result.cascadeTo,
+			...cfg.cascadeTo
+		};
+	}
+	return result;
+}
+function getBumpyDir(rootDir) {
+	return resolve(rootDir, BUMPY_DIR);
+}
+/**
+* Determine if a package should be managed by bumpy.
+* Resolution order:
+* 1. Per-package `managed: false` → skip (explicit opt-out)
+* 2. `config.ignore` glob match → skip
+* 3. Per-package `managed: true` → include (explicit opt-in, overrides private)
+* 4. `config.include` glob match → include (overrides private)
+* 5. Private package + `config.privatePackages.version` false → skip
+* 6. Otherwise → include
+*/
+function isPackageManaged(pkgName, isPrivate, config, pkgBumpy) {
+	if (pkgBumpy?.managed === false) return false;
+	if (config.ignore.some((pattern) => matchGlob(pkgName, pattern))) {
+		if (pkgBumpy?.managed === true) return true;
+		if (config.include.some((pattern) => matchGlob(pkgName, pattern))) return true;
+		return false;
+	}
+	if (pkgBumpy?.managed === true) return true;
+	if (config.include.some((pattern) => matchGlob(pkgName, pattern))) return true;
+	if (isPrivate && !config.privatePackages.version) return false;
+	return true;
+}
+//#endregion
+export { loadConfig as a, BUMP_LEVELS as c, DEFAULT_PUBLISH_CONFIG as d, DEP_TYPES as f, parseIsolatedBump as g, maxBump as h, isPackageManaged as i, DEFAULT_BUMP_RULES as l, hasCascade as m, findRoot as n, loadPackageConfig as o, bumpLevel as p, getBumpyDir as r, matchGlob as s, config_exports as t, DEFAULT_CONFIG as u };

package/dist/dep-graph-E-9-eQ2J.mjs

@@ -0,0 +1,64 @@
+//#region src/core/dep-graph.ts
+var DependencyGraph = class {
+	/** Map from package name → packages that depend on it */
+	dependents = /* @__PURE__ */ new Map();
+	/** Set of all internal package names */
+	internalPackages;
+	constructor(packages) {
+		this.internalPackages = new Set(packages.keys());
+		this.build(packages);
+	}
+	build(packages) {
+		for (const [name, pkg] of packages) {
+			const depTypes = [
+				["dependencies", pkg.dependencies],
+				["devDependencies", pkg.devDependencies],
+				["peerDependencies", pkg.peerDependencies],
+				["optionalDependencies", pkg.optionalDependencies]
+			];
+			for (const [depType, deps] of depTypes) for (const [depName, versionRange] of Object.entries(deps)) {
+				if (!this.internalPackages.has(depName)) continue;
+				if (!this.dependents.has(depName)) this.dependents.set(depName, []);
+				this.dependents.get(depName).push({
+					name,
+					depType,
+					versionRange
+				});
+			}
+		}
+	}
+	/** Get all packages that depend on the given package */
+	getDependents(pkgName) {
+		return this.dependents.get(pkgName) || [];
+	}
+	/** Check if a package is an internal workspace package */
+	isInternal(pkgName) {
+		return this.internalPackages.has(pkgName);
+	}
+	/** Get all internal package names */
+	allPackages() {
+		return [...this.internalPackages];
+	}
+	/** Topological sort — returns packages in dependency order (deps first) */
+	topologicalSort(packages) {
+		const visited = /* @__PURE__ */ new Set();
+		const result = [];
+		const visit = (name) => {
+			if (visited.has(name)) return;
+			visited.add(name);
+			const pkg = packages.get(name);
+			if (!pkg) return;
+			for (const deps of [
+				pkg.dependencies,
+				pkg.devDependencies,
+				pkg.peerDependencies,
+				pkg.optionalDependencies
+			]) for (const depName of Object.keys(deps)) if (this.internalPackages.has(depName)) visit(depName);
+			result.push(name);
+		};
+		for (const name of this.internalPackages) visit(name);
+		return result;
+	}
+};
+//#endregion
+export { DependencyGraph as t };

package/dist/fs-0AtnPUUe.mjs

@@ -0,0 +1,51 @@
+import { a as __exportAll } from "./logger-C2dEe5Su.mjs";
+import { access, mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+//#region src/utils/fs.ts
+var fs_exports = /* @__PURE__ */ __exportAll({
+	ensureDir: () => ensureDir,
+	exists: () => exists,
+	listFiles: () => listFiles,
+	readJson: () => readJson,
+	readText: () => readText,
+	removeFile: () => removeFile,
+	writeJson: () => writeJson,
+	writeText: () => writeText
+});
+async function readJson(filePath) {
+	const content = await readFile(filePath, "utf-8");
+	return JSON.parse(content);
+}
+async function writeJson(filePath, data, indent = 2) {
+	await writeFile(filePath, JSON.stringify(data, null, indent) + "\n", "utf-8");
+}
+async function readText(filePath) {
+	return readFile(filePath, "utf-8");
+}
+async function writeText(filePath, content) {
+	await writeFile(filePath, content, "utf-8");
+}
+async function exists(filePath) {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function listFiles(dir, ext) {
+	try {
+		const entries = await readdir(dir);
+		if (ext) return entries.filter((e) => e.endsWith(ext));
+		return entries;
+	} catch {
+		return [];
+	}
+}
+async function removeFile(filePath) {
+	await unlink(filePath);
+}
+async function ensureDir(dir) {
+	await mkdir(dir, { recursive: true });
+}
+//#endregion
+export { readJson as a, writeJson as c, listFiles as i, writeText as l, exists as n, readText as o, fs_exports as r, removeFile as s, ensureDir as t };