@varlock/bumpy 0.0.0 → 0.0.2

package/dist/shell-Dj7JRD_q.mjs

@@ -0,0 +1,92 @@
+import { a as __exportAll } from "./logger-C2dEe5Su.mjs";
+import { exec, execFile, execFileSync } from "node:child_process";
+//#region src/utils/shell.ts
+var shell_exports = /* @__PURE__ */ __exportAll({
+	runArgs: () => runArgs,
+	runArgsAsync: () => runArgsAsync,
+	runAsync: () => runAsync,
+	sq: () => sq,
+	tryRunArgs: () => tryRunArgs
+});
+/**
+* Escape a value for safe interpolation inside a single-quoted shell string.
+* Works by ending the current single-quote, inserting an escaped single-quote,
+* and re-opening the single-quote: "it's" → 'it'\''s'
+*/
+function sq(value) {
+	return "'" + value.replace(/'/g, "'\\''") + "'";
+}
+function checkIntercept(args, opts) {
+	return null;
+}
+function runAsync(cmd, opts) {
+	const result = checkIntercept(cmd.split(/\s+/), opts);
+	if (result?.intercepted) {
+		if ("error" in result) return Promise.reject(new Error(result.error));
+		return Promise.resolve(result.result);
+	}
+	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();
+		}
+	});
+}
+/** Run a command with an argument array — bypasses the shell entirely */
+function runArgs(args, opts) {
+	const result = checkIntercept(args, opts);
+	if (result?.intercepted) {
+		if ("error" in result) throw new Error(result.error);
+		return result.result;
+	}
+	const [cmd, ...rest] = args;
+	return execFileSync(cmd, rest, {
+		cwd: opts?.cwd,
+		input: opts?.input,
+		encoding: "utf-8",
+		stdio: [
+			opts?.input ? "pipe" : "pipe",
+			"pipe",
+			"pipe"
+		]
+	}).trim();
+}
+/** Async version of runArgs */
+function runArgsAsync(args, opts) {
+	const result = checkIntercept(args, opts);
+	if (result?.intercepted) {
+		if ("error" in result) return Promise.reject(new Error(result.error));
+		return Promise.resolve(result.result);
+	}
+	const [cmd, ...rest] = args;
+	return new Promise((resolve, reject) => {
+		const child = execFile(cmd, rest, {
+			cwd: opts?.cwd,
+			encoding: "utf-8"
+		}, (err, stdout, stderr) => {
+			if (err) reject(/* @__PURE__ */ new Error(`Command failed: ${args.join(" ")}\n${stderr}`));
+			else resolve(stdout.trim());
+		});
+		if (opts?.input) {
+			child.stdin?.write(opts.input);
+			child.stdin?.end();
+		}
+	});
+}
+/** tryRun equivalent for argument arrays */
+function tryRunArgs(args, opts) {
+	try {
+		return runArgs(args, opts);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { sq as a, shell_exports as i, runArgsAsync as n, tryRunArgs as o, runAsync as r, runArgs as t };

package/dist/status--Q8yAxQ4.mjs

@@ -0,0 +1,106 @@
+import { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
+import { a as loadConfig } from "./config-BkwIEaQg.mjs";
+import { t as discoverPackages } from "./workspace-CxEKakDm.mjs";
+import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
+import { r as readChangesets } from "./changeset-UCZdSRDv.mjs";
+import { t as assembleReleasePlan } from "./release-plan-BEzwApuK.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-BkwIEaQg.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-cAUkfYPx.mjs

@@ -0,0 +1,120 @@
+import { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
+import { a as loadConfig } from "./config-BkwIEaQg.mjs";
+import { n as detectWorkspaces } from "./package-manager-DcI5TdDE.mjs";
+import { t as discoverPackages } from "./workspace-CxEKakDm.mjs";
+import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
+import { o as tryRunArgs, t as runArgs } from "./shell-Dj7JRD_q.mjs";
+import { r as readChangesets } from "./changeset-UCZdSRDv.mjs";
+import { t as assembleReleasePlan } from "./release-plan-BEzwApuK.mjs";
+import { t as applyReleasePlan } from "./apply-release-plan-D6TSrcwX.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 {
+		runArgs([
+			"git",
+			"add",
+			"-A",
+			".bumpy/"
+		], { cwd: rootDir });
+		for (const r of plan.releases) {
+			const pkg = packages.get(r.name);
+			runArgs([
+				"git",
+				"add",
+				"--",
+				`${pkg.relativeDir}/package.json`
+			], { cwd: rootDir });
+			runArgs([
+				"git",
+				"add",
+				"--",
+				`${pkg.relativeDir}/CHANGELOG.md`
+			], { cwd: rootDir });
+		}
+		for (const lockfile of [
+			"bun.lock",
+			"bun.lockb",
+			"pnpm-lock.yaml",
+			"yarn.lock",
+			"package-lock.json"
+		]) tryRunArgs([
+			"git",
+			"add",
+			"--",
+			lockfile
+		], { cwd: rootDir });
+		runArgs([
+			"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 installArgs = getInstallArgs(packageManager);
+	log.step(`Updating lockfile (${installArgs.join(" ")})...`);
+	try {
+		runArgs(installArgs, { cwd: rootDir });
+		log.dim("  Lockfile updated");
+	} catch (err) {
+		log.warn(`  Lockfile update failed: ${err instanceof Error ? err.message : err}`);
+	}
+}
+function getInstallArgs(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-CxEKakDm.mjs

@@ -0,0 +1,107 @@
+import { a as readJson, n as exists } from "./fs-0AtnPUUe.mjs";
+import { i as isPackageManaged, o as loadPackageConfig } from "./config-BkwIEaQg.mjs";
+import { n as detectWorkspaces } from "./package-manager-DcI5TdDE.mjs";
+import { relative, resolve } from "node:path";
+import { readdir, stat } from "node:fs/promises";
+//#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 { discoverWorkspace as n, discoverPackages as t };

package/package.json

@@ -1,8 +1,40 @@
 {
   "name": "@varlock/bumpy",
-  "description": "Modern monorepo versioning and changelog tool 🐸",
-  "version": "0.0.0",
-  "files": [],
-  "author": "dmno-dev",
-  "license": "MIT"
-}
+  "version": "0.0.2",
+  "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",
+    "check": "bun run tsc --noEmit",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "@clack/prompts": "^1.2.0",
+    "@types/bun": "latest",
+    "@types/js-yaml": "^4.0.9",
+    "@types/semver": "^7.7.0",
+    "js-yaml": "^4.1.0",
+    "picocolors": "^1.1.1",
+    "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