@varlock/bumpy 0.0.0 → 0.0.1

package/dist/shell-DPlltpzb.mjs

@@ -0,0 +1,44 @@
+import { i as __exportAll } from "./logger-ZqggsyGZ.mjs";
+import { exec, execSync } from "node:child_process";
+//#region src/utils/shell.ts
+var shell_exports = /* @__PURE__ */ __exportAll({
+	run: () => run,
+	runAsync: () => runAsync,
+	tryRun: () => tryRun
+});
+function run(cmd, opts) {
+	return execSync(cmd, {
+		cwd: opts?.cwd,
+		input: opts?.input,
+		encoding: "utf-8",
+		stdio: [
+			opts?.input ? "pipe" : "pipe",
+			"pipe",
+			"pipe"
+		]
+	}).trim();
+}
+function runAsync(cmd, opts) {
+	return new Promise((resolve, reject) => {
+		const child = exec(cmd, {
+			cwd: opts?.cwd,
+			encoding: "utf-8"
+		}, (err, stdout, stderr) => {
+			if (err) reject(/* @__PURE__ */ new Error(`Command failed: ${cmd}\n${stderr}`));
+			else resolve(stdout.trim());
+		});
+		if (opts?.input) {
+			child.stdin?.write(opts.input);
+			child.stdin?.end();
+		}
+	});
+}
+function tryRun(cmd, opts) {
+	try {
+		return run(cmd, opts);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { tryRun as i, runAsync as n, shell_exports as r, run as t };

package/dist/status-DRpq_Mha.mjs

@@ -0,0 +1,106 @@
+import { n as log, t as colorize } from "./logger-ZqggsyGZ.mjs";
+import { a as loadConfig } from "./config-CJ2orhTL.mjs";
+import { t as discoverPackages } from "./workspace-mVjawG8g.mjs";
+import { t as DependencyGraph } from "./dep-graph-DiLeAhl9.mjs";
+import { r as readChangesets } from "./changeset-ClCYsChu.mjs";
+import { t as assembleReleasePlan } from "./release-plan-CFnutSHD.mjs";
+//#region src/commands/status.ts
+async function statusCommand(rootDir, opts) {
+	const config = await loadConfig(rootDir);
+	const packages = await discoverPackages(rootDir, config);
+	const depGraph = new DependencyGraph(packages);
+	const changesets = await readChangesets(rootDir);
+	if (changesets.length === 0) {
+		if (opts.json) console.log(JSON.stringify({
+			changesets: [],
+			releases: [],
+			packageNames: []
+		}, null, 2));
+		else if (!opts.packagesOnly) log.info("No pending changesets.");
+		process.exit(1);
+	}
+	const plan = assembleReleasePlan(changesets, packages, depGraph, config);
+	let releases = plan.releases;
+	if (opts.bumpType) {
+		const types = opts.bumpType.split(",").map((t) => t.trim());
+		releases = releases.filter((r) => types.includes(r.type));
+	}
+	if (opts.filter) {
+		const { matchGlob } = await import("./config-CJ2orhTL.mjs").then((n) => n.t);
+		const patterns = opts.filter.split(",").map((p) => p.trim());
+		releases = releases.filter((r) => patterns.some((p) => matchGlob(r.name, p)));
+	}
+	if (opts.json) {
+		const jsonOutput = {
+			changesets: plan.changesets.map((cs) => ({
+				id: cs.id,
+				summary: cs.summary,
+				releases: cs.releases.map((r) => ({
+					name: r.name,
+					type: r.type
+				}))
+			})),
+			releases: releases.map((r) => ({
+				name: r.name,
+				type: r.type,
+				oldVersion: r.oldVersion,
+				newVersion: r.newVersion,
+				dir: packages.get(r.name)?.relativeDir,
+				changesets: r.changesets,
+				isDependencyBump: r.isDependencyBump,
+				isCascadeBump: r.isCascadeBump
+			})),
+			packageNames: releases.map((r) => r.name)
+		};
+		console.log(JSON.stringify(jsonOutput, null, 2));
+		return;
+	}
+	if (opts.packagesOnly) {
+		for (const r of releases) console.log(r.name);
+		return;
+	}
+	log.bold(`${changesets.length} changeset(s) pending\n`);
+	if (releases.length === 0) {
+		log.warn("No packages match the current filters.");
+		return;
+	}
+	const groups = [
+		[
+			"Major",
+			"red",
+			releases.filter((r) => r.type === "major")
+		],
+		[
+			"Minor",
+			"yellow",
+			releases.filter((r) => r.type === "minor")
+		],
+		[
+			"Patch",
+			"green",
+			releases.filter((r) => r.type === "patch")
+		]
+	];
+	for (const [label, color, group] of groups) {
+		if (group.length === 0) continue;
+		log.bold(colorize(label, color));
+		for (const r of group) printRelease(r, packages);
+		console.log();
+	}
+	if (opts.verbose) {
+		log.bold("Changesets:");
+		for (const cs of plan.changesets) {
+			console.log(`  ${colorize(cs.id, "cyan")}`);
+			for (const r of cs.releases) console.log(`    ${r.name}: ${r.type}`);
+			if (cs.summary) console.log(`    ${colorize(cs.summary.split("\n")[0], "dim")}`);
+		}
+	}
+}
+function printRelease(r, packages) {
+	const pkg = packages.get(r.name);
+	const dir = pkg ? colorize(` (${pkg.relativeDir})`, "dim") : "";
+	const suffix = r.isDependencyBump ? colorize(" ← dependency bump", "dim") : r.isCascadeBump ? colorize(" ← cascade", "dim") : "";
+	console.log(`  ${r.name}: ${r.oldVersion} → ${colorize(r.newVersion, "cyan")}${suffix}${dir}`);
+}
+//#endregion
+export { statusCommand };

package/dist/version-CJwf8XIA.mjs

@@ -0,0 +1,81 @@
+import { n as log, t as colorize } from "./logger-ZqggsyGZ.mjs";
+import { a as loadConfig } from "./config-CJ2orhTL.mjs";
+import { r as detectWorkspaces, t as discoverPackages } from "./workspace-mVjawG8g.mjs";
+import { t as DependencyGraph } from "./dep-graph-DiLeAhl9.mjs";
+import { r as readChangesets } from "./changeset-ClCYsChu.mjs";
+import { t as assembleReleasePlan } from "./release-plan-CFnutSHD.mjs";
+import { t as applyReleasePlan } from "./apply-release-plan-DtU3rVyL.mjs";
+import { i as tryRun, t as run } from "./shell-DPlltpzb.mjs";
+//#region src/commands/version.ts
+async function versionCommand(rootDir) {
+	const config = await loadConfig(rootDir);
+	const packages = await discoverPackages(rootDir, config);
+	const depGraph = new DependencyGraph(packages);
+	const changesets = await readChangesets(rootDir);
+	if (changesets.length === 0) {
+		log.info("No pending changesets.");
+		return;
+	}
+	const plan = assembleReleasePlan(changesets, packages, depGraph, config);
+	if (plan.releases.length === 0) {
+		log.warn("Changesets found but no packages would be released.");
+		return;
+	}
+	log.step("Applying version bumps:");
+	for (const r of plan.releases) {
+		const tag = r.isDependencyBump ? " (dep)" : r.isCascadeBump ? " (cascade)" : "";
+		console.log(`  ${r.name}: ${r.oldVersion} → ${colorize(r.newVersion, "cyan")}${tag}`);
+	}
+	await applyReleasePlan(plan, packages, rootDir, config);
+	log.success(`Updated ${plan.releases.length} package(s)`);
+	log.dim(`  Deleted ${changesets.length} changeset file(s)`);
+	await updateLockfile(rootDir);
+	if (config.commit) try {
+		run("git add -A .bumpy/", { cwd: rootDir });
+		for (const r of plan.releases) {
+			const pkg = packages.get(r.name);
+			run(`git add "${pkg.relativeDir}/package.json"`, { cwd: rootDir });
+			run(`git add "${pkg.relativeDir}/CHANGELOG.md"`, { cwd: rootDir });
+		}
+		for (const lockfile of [
+			"bun.lock",
+			"bun.lockb",
+			"pnpm-lock.yaml",
+			"yarn.lock",
+			"package-lock.json"
+		]) tryRun(`git add "${lockfile}"`, { cwd: rootDir });
+		run("git commit -F -", {
+			cwd: rootDir,
+			input: [
+				"Version packages",
+				"",
+				...plan.releases.map((r) => `${r.name}@${r.newVersion}`)
+			].join("\n")
+		});
+		log.success("Created git commit");
+	} catch (e) {
+		log.warn(`Git commit failed: ${e}`);
+	}
+}
+/** Run the package manager's install to update the lockfile */
+async function updateLockfile(rootDir) {
+	const { packageManager } = await detectWorkspaces(rootDir);
+	const installCmd = getInstallCommand(packageManager);
+	log.step(`Updating lockfile (${installCmd})...`);
+	try {
+		run(installCmd, { cwd: rootDir });
+		log.dim("  Lockfile updated");
+	} catch (err) {
+		log.warn(`  Lockfile update failed: ${err instanceof Error ? err.message : err}`);
+	}
+}
+function getInstallCommand(pm) {
+	switch (pm) {
+		case "pnpm": return "pnpm install --lockfile-only";
+		case "bun": return "bun install";
+		case "yarn": return "yarn install --mode update-lockfile";
+		default: return "npm install --package-lock-only";
+	}
+}
+//#endregion
+export { versionCommand };

package/dist/workspace-mVjawG8g.mjs

@@ -0,0 +1,183 @@
+import { a as readJson, n as exists, o as readText } from "./fs-DbNNEyzq.mjs";
+import { i as isPackageManaged, o as loadPackageConfig } from "./config-CJ2orhTL.mjs";
+import { t as jsYaml } from "./js-yaml-DpZfOoD4.mjs";
+import { relative, resolve } from "node:path";
+import { readdir, stat } from "node:fs/promises";
+//#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
+//#region src/core/workspace.ts
+/** Discover all workspace packages and catalogs in a monorepo */
+async function discoverWorkspace(rootDir, config) {
+	const { globs, catalogs } = await detectWorkspaces(rootDir);
+	if (globs.length === 0) throw new Error("No workspace globs found. Is this a monorepo?");
+	const packages = /* @__PURE__ */ new Map();
+	for (const glob of globs) {
+		const dirs = await resolveGlob(rootDir, glob);
+		for (const dir of dirs) {
+			const pkg = await loadWorkspacePackage(dir, rootDir, config);
+			if (pkg) {
+				if (!isPackageManaged(pkg.name, pkg.private, config, pkg.bumpy)) continue;
+				packages.set(pkg.name, pkg);
+			}
+		}
+	}
+	return {
+		packages,
+		catalogs
+	};
+}
+/** Convenience wrapper that returns just packages (backwards compat) */
+async function discoverPackages(rootDir, config) {
+	const { packages } = await discoverWorkspace(rootDir, config);
+	return packages;
+}
+/** Resolve a workspace glob pattern to directories containing package.json */
+async function resolveGlob(rootDir, pattern) {
+	return expandGlob(rootDir, pattern.split("/"));
+}
+async function expandGlob(baseDir, parts) {
+	if (parts.length === 0) {
+		if (await exists(resolve(baseDir, "package.json"))) return [baseDir];
+		return [];
+	}
+	const [current, ...rest] = parts;
+	if (current === "*") {
+		const entries = await safeReaddir(baseDir);
+		const results = [];
+		for (const entry of entries) {
+			const entryPath = resolve(baseDir, entry);
+			if (await isDirectory(entryPath)) results.push(...await expandGlob(entryPath, rest));
+		}
+		return results;
+	} else if (current === "**") {
+		const results = [];
+		results.push(...await expandGlob(baseDir, rest));
+		const entries = await safeReaddir(baseDir);
+		for (const entry of entries) {
+			if (entry.startsWith(".") || entry === "node_modules") continue;
+			const entryPath = resolve(baseDir, entry);
+			if (await isDirectory(entryPath)) results.push(...await expandGlob(entryPath, parts));
+		}
+		return results;
+	} else {
+		const next = resolve(baseDir, current);
+		if (await isDirectory(next)) return expandGlob(next, rest);
+		return [];
+	}
+}
+async function safeReaddir(dir) {
+	try {
+		return await readdir(dir);
+	} catch {
+		return [];
+	}
+}
+async function isDirectory(path) {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function loadWorkspacePackage(dir, rootDir, config) {
+	const pkgPath = resolve(dir, "package.json");
+	if (!await exists(pkgPath)) return null;
+	let pkg;
+	try {
+		pkg = await readJson(pkgPath);
+	} catch {
+		return null;
+	}
+	const name = pkg.name;
+	if (!name) return null;
+	const bumpy = await loadPackageConfig(dir, config, name);
+	return {
+		name,
+		version: pkg.version || "0.0.0",
+		dir: resolve(dir),
+		relativeDir: relative(rootDir, dir),
+		packageJson: pkg,
+		private: !!pkg.private,
+		dependencies: pkg.dependencies || {},
+		devDependencies: pkg.devDependencies || {},
+		peerDependencies: pkg.peerDependencies || {},
+		optionalDependencies: pkg.optionalDependencies || {},
+		bumpy
+	};
+}
+//#endregion
+export { resolveCatalogDep as i, discoverWorkspace as n, detectWorkspaces as r, discoverPackages as t };

package/package.json

@@ -1,8 +1,38 @@
 {
   "name": "@varlock/bumpy",
-  "description": "Modern monorepo versioning and changelog tool 🐸",
-  "version": "0.0.0",
-  "files": [],
-  "author": "dmno-dev",
-  "license": "MIT"
-}
+  "version": "0.0.1",
+  "description": "Modern monorepo versioning and changelog tool",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dmno-dev/bumpy",
+    "directory": "packages/bumpy"
+  },
+  "bin": {
+    "bumpy": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    ".claude-plugin",
+    "skills"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/js-yaml": "^4.0.9",
+    "@types/semver": "^7.7.0",
+    "ansis": "^4.2.0",
+    "js-yaml": "^4.1.0",
+    "semver": "^7.7.2",
+    "tsdown": "^0.21.8"
+  }
+}

package/skills/add-change/SKILL.md

@@ -0,0 +1,108 @@
+---
+name: add-change
+description: Create a bumpy changeset describing which packages changed and how, for version bumping and changelog generation. Use when the user wants to record a change, add a changeset, or prepare packages for release.
+argument-hint: '[description of changes]'
+allowed-tools: Read Grep Glob Bash Edit Write
+---
+
+# Create a bumpy changeset
+
+You are helping the user create a **bumpy changeset** — a markdown file in `.bumpy/` that describes which packages changed and how. Bumpy uses these to bump versions and generate changelogs.
+
+## Steps
+
+### 1. Gather context
+
+First, understand what changed. Run these in parallel:
+
+- `git diff --stat` — see which files changed
+- `git diff --cached --stat` — see staged changes
+- `bumpy status --json` — see if there are already pending changesets
+
+If the user provided a description via `$ARGUMENTS`, use that as additional context for understanding the change.
+
+Review the diff output to understand the scope of changes.
+
+### 2. Identify affected packages
+
+Determine which workspace packages are affected by the changes. Map changed files to their packages based on directory structure.
+
+If unsure which packages exist, run:
+
+```bash
+bumpy status --packages 2>/dev/null || cat package.json
+```
+
+### 3. Determine bump levels
+
+For each affected package, choose the appropriate bump level:
+
+| Level     | When to use                                                                             |
+| --------- | --------------------------------------------------------------------------------------- |
+| **major** | Breaking changes: removed/renamed exports, changed function signatures, dropped support |
+| **minor** | New features: added exports, new options, new functionality                             |
+| **patch** | Bug fixes, internal refactors, documentation, dependency updates                        |
+
+Append `-isolated` (e.g., `patch-isolated`) if the change is purely internal and dependents should NOT be bumped. Use this for:
+
+- Internal refactors with no API changes
+- Dev tooling / test changes
+- Documentation-only changes
+
+### 4. Write a clear summary
+
+Write a concise summary (1-3 sentences) describing **what** changed and **why**. This becomes the CHANGELOG entry. Good summaries:
+
+- Start with a verb: "Added...", "Fixed...", "Refactored..."
+- Focus on user-facing impact, not implementation details
+- Are specific enough to be useful months later
+
+### 5. Create the changeset
+
+Use the non-interactive CLI:
+
+```bash
+bumpy add \
+  --packages "<pkg1>:<bump>,<pkg2>:<bump>" \
+  --message "<summary>" \
+  --name "<short-descriptive-name>"
+```
+
+The `--name` should be a short kebab-case slug describing the change (e.g., `fix-auth-token-refresh`, `add-encryption-api`).
+
+### Example
+
+If the user fixed a bug in `@myorg/auth` that also required a type change in `@myorg/types`:
+
+```bash
+bumpy add \
+  --packages "@myorg/auth:patch,@myorg/types:patch" \
+  --message "Fixed token refresh failing silently when the refresh token has expired." \
+  --name "fix-token-refresh"
+```
+
+## Advanced: cascading bumps
+
+If a change in a core package should explicitly cascade to dependents with specific bump levels, write the changeset file directly instead of using the CLI:
+
+```bash
+cat > .bumpy/<name>.md << 'EOF'
+---
+"@myorg/core":
+  bump: minor
+  cascade:
+    "@myorg/plugin-*": patch
+    "@myorg/cli": minor
+"@myorg/utils": patch
+---
+
+Added new encryption provider. Plugins need a patch bump for compatibility.
+EOF
+```
+
+## Important notes
+
+- Only include packages that have **actual code changes** — bumpy handles dependency propagation automatically
+- If the user hasn't made any changes yet, ask what they're planning to change
+- If the change doesn't affect any publishable packages (e.g., only root config files), suggest using `bumpy add --empty` to satisfy CI checks
+- One changeset per logical change — don't combine unrelated changes