@varlock/bumpy 0.0.0 → 0.0.1

package/.claude-plugin/plugin.json

@@ -0,0 +1,13 @@
+{
+  "name": "bumpy",
+  "version": "0.0.1",
+  "description": "AI-assisted changeset creation for bumpy monorepo versioning",
+  "author": {
+    "name": "DMNO",
+    "url": "https://github.com/dmno-dev"
+  },
+  "repository": "https://github.com/dmno-dev/bumpy",
+  "license": "MIT",
+  "keywords": ["monorepo", "versioning", "changelog", "changesets"],
+  "skills": "./skills/"
+}

package/dist/add-u5V9V3L7.mjs

@@ -0,0 +1,131 @@
+import { n as log, t as colorize } from "./logger-ZqggsyGZ.mjs";
+import { n as exists, t as ensureDir } from "./fs-DbNNEyzq.mjs";
+import { a as loadConfig, r as getBumpyDir, s as matchGlob } from "./config-CJ2orhTL.mjs";
+import { t as discoverPackages } from "./workspace-mVjawG8g.mjs";
+import { t as DependencyGraph } from "./dep-graph-DiLeAhl9.mjs";
+import { i as writeChangeset } from "./changeset-ClCYsChu.mjs";
+import { i as select, n as confirm, r as multiSelect, t as ask } from "./prompt-BP8toAOI.mjs";
+import { n as slugify, t as randomName } from "./names-C-u50ofE.mjs";
+import { resolve } from "node:path";
+//#region src/commands/add.ts
+const BUMP_CHOICES = [
+	{
+		label: "patch",
+		value: "patch"
+	},
+	{
+		label: "minor",
+		value: "minor"
+	},
+	{
+		label: "major",
+		value: "major"
+	},
+	{
+		label: "patch (isolated - no cascade)",
+		value: "patch-isolated"
+	},
+	{
+		label: "minor (isolated - no cascade)",
+		value: "minor-isolated"
+	}
+];
+async function addCommand(rootDir, opts) {
+	const config = await loadConfig(rootDir);
+	const bumpyDir = getBumpyDir(rootDir);
+	await ensureDir(bumpyDir);
+	if (opts.empty) {
+		const filename = opts.name ? slugify(opts.name) : randomName();
+		const filePath = resolve(bumpyDir, `${filename}.md`);
+		const { writeText } = await import("./fs-DbNNEyzq.mjs").then((n) => n.r);
+		await writeText(filePath, "---\n---\n");
+		log.success(`Created empty changeset: .bumpy/${filename}.md`);
+		return;
+	}
+	let releases;
+	let summary;
+	if (opts.packages) {
+		releases = parsePackagesFlag(opts.packages);
+		summary = opts.message || "";
+	} else {
+		const pkgs = await discoverPackages(rootDir, config);
+		const depGraph = new DependencyGraph(pkgs);
+		const selected = await multiSelect("Which packages should be included in this changeset?", [...pkgs.values()].map((p) => ({
+			label: `${p.name} (${p.version})`,
+			value: p.name
+		})));
+		if (selected.length === 0) {
+			log.warn("No packages selected. Aborting.");
+			return;
+		}
+		releases = [];
+		for (const name of selected) {
+			const bumpType = await select(`Bump type for ${colorize(name, "cyan")}:`, BUMP_CHOICES);
+			const release = {
+				name,
+				type: bumpType
+			};
+			if (!bumpType.endsWith("-isolated")) {
+				const dependents = depGraph.getDependents(name);
+				const cascadeTargets = pkgs.get(name).bumpy?.cascadeTo;
+				if (dependents.length > 0 || cascadeTargets) {
+					if (await confirm(`${name} has ${dependents.length} dependents. Specify explicit cascades?`, false)) {
+						const allTargets = /* @__PURE__ */ new Set();
+						for (const d of dependents) allTargets.add(d.name);
+						if (cascadeTargets) {
+							for (const pattern of Object.keys(cascadeTargets)) for (const [pName] of pkgs) if (matchGlob(pName, pattern)) allTargets.add(pName);
+						}
+						const cascadeSelected = await multiSelect("Which packages should cascade?", [...allTargets].map((n) => ({
+							label: n,
+							value: n
+						})));
+						if (cascadeSelected.length > 0) {
+							const cascadeBump = await select("Cascade bump type:", [
+								{
+									label: "patch",
+									value: "patch"
+								},
+								{
+									label: "minor",
+									value: "minor"
+								},
+								{
+									label: "major",
+									value: "major"
+								}
+							]);
+							const cascade = {};
+							for (const target of cascadeSelected) cascade[target] = cascadeBump;
+							release.cascade = cascade;
+						}
+					}
+				}
+			}
+			releases.push(release);
+		}
+		summary = await ask("Summary (what changed and why)");
+	}
+	let filename;
+	if (opts.name) filename = slugify(opts.name);
+	else if (opts.packages) filename = randomName();
+	else filename = slugify(await ask("Changeset name", randomName())) || randomName();
+	if (await exists(resolve(bumpyDir, `${filename}.md`))) filename = `${filename}-${Date.now()}`;
+	await writeChangeset(rootDir, filename, releases, summary);
+	log.success(`Created changeset: .bumpy/${filename}.md`);
+	for (const r of releases) {
+		const cascade = "cascade" in r && Object.keys(r.cascade).length > 0 ? ` (cascade: ${Object.entries(r.cascade).map(([k, v]) => `${k}:${v}`).join(", ")})` : "";
+		log.dim(`  ${r.name}: ${r.type}${cascade}`);
+	}
+}
+function parsePackagesFlag(input) {
+	return input.split(",").map((entry) => {
+		const [name, type] = entry.trim().split(":");
+		if (!name || !type) throw new Error(`Invalid package format: "${entry}". Expected "name:bumpType"`);
+		return {
+			name: name.trim(),
+			type: type.trim()
+		};
+	});
+}
+//#endregion
+export { addCommand };

package/dist/ai-B8ZL2x8z.mjs

@@ -0,0 +1,82 @@
+import { n as log } from "./logger-ZqggsyGZ.mjs";
+import { l as writeText, n as exists, t as ensureDir } from "./fs-DbNNEyzq.mjs";
+import { dirname, resolve } from "node:path";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+//#region src/commands/ai.ts
+const SUPPORTED_TARGETS = [
+	"opencode",
+	"cursor",
+	"codex"
+];
+async function aiSetupCommand(rootDir, opts) {
+	const target = opts.target;
+	if (!target) {
+		log.error(`Please specify a target: bumpy ai setup --target <${SUPPORTED_TARGETS.join("|")}>`);
+		log.dim("  Claude Code users: install the plugin instead — claude plugin install @varlock/bumpy");
+		process.exit(1);
+	}
+	if (!SUPPORTED_TARGETS.includes(target)) {
+		log.error(`Unknown target: "${target}". Supported: ${SUPPORTED_TARGETS.join(", ")}`);
+		process.exit(1);
+	}
+	const promptContent = await loadPromptTemplate();
+	switch (target) {
+		case "opencode":
+			await setupOpenCode(rootDir, promptContent);
+			break;
+		case "cursor":
+			await setupCursor(rootDir, promptContent);
+			break;
+		case "codex":
+			await setupCodex(rootDir, promptContent);
+			break;
+	}
+}
+async function loadPromptTemplate() {
+	return (await readFile(resolve(dirname(fileURLToPath(import.meta.url)), "../../skills/add-change/SKILL.md"), "utf-8")).replace(/^---\n[\s\S]*?\n---\n\n?/, "");
+}
+/** Install as an OpenCode custom command */
+async function setupOpenCode(rootDir, promptContent) {
+	const commandsDir = resolve(rootDir, ".opencode", "commands");
+	const targetPath = resolve(commandsDir, "add-bumpy-change.md");
+	await ensureDir(commandsDir);
+	if (await exists(targetPath)) log.warn(".opencode/commands/add-bumpy-change.md already exists — overwriting");
+	await writeText(targetPath, `---
+description: Create a bumpy changeset to track package version bumps
+---
+
+${promptContent}`);
+	log.success("Installed OpenCode command");
+	log.dim("  Created .opencode/commands/add-bumpy-change.md");
+	log.dim("  Usage: type /add-bumpy-change in OpenCode");
+}
+/** Install as a Cursor rule */
+async function setupCursor(rootDir, promptContent) {
+	const rulesDir = resolve(rootDir, ".cursor", "rules");
+	const targetPath = resolve(rulesDir, "add-bumpy-change.mdc");
+	await ensureDir(rulesDir);
+	if (await exists(targetPath)) log.warn(".cursor/rules/add-bumpy-change.mdc already exists — overwriting");
+	await writeText(targetPath, `---
+description: Create a bumpy changeset to track package version bumps
+globs:
+alwaysApply: false
+---
+
+${promptContent}`);
+	log.success("Installed Cursor rule");
+	log.dim("  Created .cursor/rules/add-bumpy-change.mdc");
+	log.dim("  The rule will be suggested when relevant, or you can reference it manually");
+}
+/** Install as a Codex instruction */
+async function setupCodex(rootDir, promptContent) {
+	const targetPath = resolve(rootDir, ".codex", "add-bumpy-change.md");
+	await ensureDir(resolve(rootDir, ".codex"));
+	if (await exists(targetPath)) log.warn(".codex/add-bumpy-change.md already exists — overwriting");
+	await writeText(targetPath, promptContent);
+	log.success("Installed Codex instruction");
+	log.dim("  Created .codex/add-bumpy-change.md");
+	log.dim("  Reference this file in your AGENTS.md or pass it as context");
+}
+//#endregion
+export { aiSetupCommand };

package/dist/apply-release-plan-DtU3rVyL.mjs

@@ -0,0 +1,132 @@
+import { n as log } from "./logger-ZqggsyGZ.mjs";
+import { a as readJson, c as writeJson, l as writeText, n as exists, o as readText } from "./fs-DbNNEyzq.mjs";
+import { t as deleteChangesets } from "./changeset-ClCYsChu.mjs";
+import { resolve } from "node:path";
+//#region src/core/changelog.ts
+/** Default formatter — version heading, date, bullet points */
+const defaultFormatter = (ctx) => {
+	const { release, changesets, date } = ctx;
+	const lines = [];
+	lines.push(`## ${release.newVersion}`);
+	lines.push("");
+	lines.push(`_${date}_`);
+	lines.push("");
+	const relevantChangesets = changesets.filter((cs) => release.changesets.includes(cs.id));
+	if (relevantChangesets.length > 0) {
+		for (const cs of relevantChangesets) if (cs.summary) {
+			const summaryLines = cs.summary.split("\n");
+			lines.push(`- ${summaryLines[0]}`);
+			for (let i = 1; i < summaryLines.length; i++) if (summaryLines[i].trim()) lines.push(`  ${summaryLines[i]}`);
+		}
+	}
+	if (release.isDependencyBump && relevantChangesets.length === 0) lines.push("- Updated dependencies");
+	if (release.isCascadeBump && !release.isDependencyBump && relevantChangesets.length === 0) lines.push("- Version bump via cascade rule");
+	lines.push("");
+	return lines.join("\n");
+};
+const BUILTIN_FORMATTERS = {
+	default: defaultFormatter,
+	github: async () => {
+		const { createGithubFormatter } = await import("./changelog-github-n-3zV1p9.mjs");
+		return createGithubFormatter();
+	}
+};
+/**
+* Load a changelog formatter from config.
+* Supports: "default", "./path/to/formatter.ts", or a module name.
+*/
+async function loadFormatter(changelog, rootDir) {
+	const [name, options] = Array.isArray(changelog) ? changelog : [changelog, {}];
+	if (typeof name === "string" && BUILTIN_FORMATTERS[name]) {
+		const builtin = BUILTIN_FORMATTERS[name];
+		if (typeof builtin === "function" && builtin.length === 0) return builtin();
+		return builtin;
+	}
+	if (name === "github") {
+		const { createGithubFormatter } = await import("./changelog-github-n-3zV1p9.mjs");
+		return createGithubFormatter(options);
+	}
+	if (typeof name === "string") try {
+		const mod = await (name.startsWith(".") ? import(resolve(rootDir, name)) : import(name));
+		const exported = mod.default || mod.changelogFormatter;
+		if (typeof exported === "function") {
+			const result = exported(options);
+			if (typeof result === "function") return result;
+			return exported;
+		}
+		throw new Error(`Changelog module "${name}" does not export a function`);
+	} catch (err) {
+		log.warn(`Failed to load changelog formatter "${name}": ${err instanceof Error ? err.message : err}`);
+		log.warn("Falling back to default formatter");
+		return defaultFormatter;
+	}
+	return defaultFormatter;
+}
+/** Generate a changelog entry using the configured formatter */
+async function generateChangelogEntry(release, changesets, formatter = defaultFormatter, date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0]) {
+	return formatter({
+		release,
+		changesets,
+		date
+	});
+}
+/** Prepend a new entry to an existing CHANGELOG.md content */
+function prependToChangelog(existingContent, newEntry) {
+	const headerMatch = existingContent.match(/^# /m);
+	if (headerMatch && headerMatch.index !== void 0) {
+		const afterTitle = existingContent.indexOf("\n##");
+		if (afterTitle !== -1) return existingContent.slice(0, afterTitle + 1) + "\n" + newEntry + existingContent.slice(afterTitle + 1);
+		return existingContent.trimEnd() + "\n\n" + newEntry;
+	}
+	return "# Changelog\n\n" + newEntry;
+}
+//#endregion
+//#region src/core/apply-release-plan.ts
+/** Apply the release plan: bump versions, update changelogs, delete changesets */
+async function applyReleasePlan(releasePlan, packages, rootDir, config) {
+	const releaseMap = new Map(releasePlan.releases.map((r) => [r.name, r]));
+	const formatter = await loadFormatter(config.changelog, rootDir);
+	for (const release of releasePlan.releases) {
+		const pkgJsonPath = resolve(packages.get(release.name).dir, "package.json");
+		const pkgJson = await readJson(pkgJsonPath);
+		pkgJson.version = release.newVersion;
+		for (const depField of [
+			"dependencies",
+			"devDependencies",
+			"peerDependencies",
+			"optionalDependencies"
+		]) {
+			const deps = pkgJson[depField];
+			if (!deps) continue;
+			for (const [depName, range] of Object.entries(deps)) {
+				const depRelease = releaseMap.get(depName);
+				if (!depRelease) continue;
+				deps[depName] = updateRange(range, depRelease.newVersion);
+			}
+		}
+		await writeJson(pkgJsonPath, pkgJson);
+	}
+	for (const release of releasePlan.releases) {
+		const changelogPath = resolve(packages.get(release.name).dir, "CHANGELOG.md");
+		const entry = await generateChangelogEntry(release, releasePlan.changesets, formatter);
+		let existingContent = "";
+		if (await exists(changelogPath)) existingContent = await readText(changelogPath);
+		await writeText(changelogPath, prependToChangelog(existingContent, entry));
+	}
+	await deleteChangesets(rootDir, releasePlan.changesets.map((cs) => cs.id));
+}
+/** Update a version range to include a new version, preserving the range prefix */
+function updateRange(range, newVersion) {
+	let protocol = "";
+	let cleanRange = range;
+	const protoMatch = range.match(/^(workspace:|catalog:)/);
+	if (protoMatch) {
+		protocol = protoMatch[1];
+		cleanRange = range.slice(protocol.length);
+	}
+	const prefix = cleanRange.match(/^(\^|~|>=|>|<=|<|=)?/)?.[1] ?? "^";
+	if (cleanRange === "*" || cleanRange === "") return range;
+	return `${protocol}${prefix}${newVersion}`;
+}
+//#endregion
+export { prependToChangelog as a, loadFormatter as i, defaultFormatter as n, generateChangelogEntry as r, applyReleasePlan as t };

package/dist/changelog-github-n-3zV1p9.mjs

@@ -0,0 +1,59 @@
+import { i as tryRun } from "./shell-DPlltpzb.mjs";
+//#region src/core/changelog-github.ts
+/**
+* GitHub-enhanced changelog formatter.
+* Adds PR links and author attribution when git/gh info is available.
+*
+* Usage in config:
+*   "changelog": "github"
+*   "changelog": ["github", { "repo": "dmno-dev/bumpy" }]
+*/
+function createGithubFormatter(options = {}) {
+	return async (ctx) => {
+		const { release, changesets, date } = ctx;
+		const lines = [];
+		lines.push(`## ${release.newVersion}`);
+		lines.push("");
+		lines.push(`_${date}_`);
+		lines.push("");
+		const relevantChangesets = changesets.filter((cs) => release.changesets.includes(cs.id));
+		if (relevantChangesets.length > 0) for (const cs of relevantChangesets) {
+			if (!cs.summary) continue;
+			const firstLine = cs.summary.split("\n")[0];
+			const prInfo = await findPrForChangeset(cs.id, options.repo);
+			if (prInfo) lines.push(`- ${firstLine} ([#${prInfo.number}](${prInfo.url})) by @${prInfo.author}`);
+			else lines.push(`- ${firstLine}`);
+			const summaryLines = cs.summary.split("\n");
+			for (let i = 1; i < summaryLines.length; i++) if (summaryLines[i].trim()) lines.push(`  ${summaryLines[i]}`);
+		}
+		if (release.isDependencyBump && relevantChangesets.length === 0) lines.push("- Updated dependencies");
+		if (release.isCascadeBump && !release.isDependencyBump && relevantChangesets.length === 0) lines.push("- Version bump via cascade rule");
+		lines.push("");
+		return lines.join("\n");
+	};
+}
+/**
+* Find the PR that introduced a changeset file by checking git log
+* for the commit that added the file, then looking up the PR.
+*/
+async function findPrForChangeset(changesetId, repo) {
+	try {
+		const commitHash = tryRun(`git log --diff-filter=A --format="%H" -- ".bumpy/${changesetId}.md" ".changeset/${changesetId}.md"`);
+		if (!commitHash) return null;
+		const hash = commitHash.split("\n")[0].trim();
+		if (!hash) return null;
+		const prJson = tryRun(`gh pr list --search "${hash}" --state merged --json number,url,author --jq ".[0]" ${repo ? `--repo ${repo}` : ""}`);
+		if (!prJson) return null;
+		const pr = JSON.parse(prJson);
+		if (!pr.number) return null;
+		return {
+			number: pr.number,
+			url: pr.url,
+			author: pr.author?.login || "unknown"
+		};
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { createGithubFormatter };

package/dist/changeset-ClCYsChu.mjs

@@ -0,0 +1,75 @@
+import { i as listFiles, l as writeText, o as readText, s as removeFile } from "./fs-DbNNEyzq.mjs";
+import { r as getBumpyDir } from "./config-CJ2orhTL.mjs";
+import { t as jsYaml } from "./js-yaml-DpZfOoD4.mjs";
+import { resolve } from "node:path";
+//#region src/core/changeset.ts
+/** Read all changeset files from .bumpy/ directory */
+async function readChangesets(rootDir) {
+	const dir = getBumpyDir(rootDir);
+	const files = await listFiles(dir, ".md");
+	const changesets = [];
+	for (const file of files) {
+		if (file === "README.md") continue;
+		const cs = await parseChangesetFile(resolve(dir, file));
+		if (cs) changesets.push(cs);
+	}
+	return changesets;
+}
+/** Parse a single changeset markdown file */
+async function parseChangesetFile(filePath) {
+	return parseChangeset(await readText(filePath), fileToId(filePath));
+}
+/** Parse changeset content (for testing) */
+function parseChangeset(content, id) {
+	const match = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+	if (!match) return null;
+	const frontmatter = match[1];
+	const summary = match[2].trim();
+	const parsed = jsYaml.load(frontmatter);
+	if (!parsed || typeof parsed !== "object") return null;
+	const releases = [];
+	for (const [name, value] of Object.entries(parsed)) if (typeof value === "string") releases.push({
+		name,
+		type: value
+	});
+	else if (value && typeof value === "object") {
+		const obj = value;
+		const release = {
+			name,
+			type: obj.bump,
+			cascade: obj.cascade || {}
+		};
+		releases.push(release);
+	}
+	if (releases.length === 0) return null;
+	return {
+		id,
+		releases,
+		summary
+	};
+}
+/** Write a changeset file */
+async function writeChangeset(rootDir, filename, releases, summary) {
+	const filePath = resolve(getBumpyDir(rootDir), `${filename}.md`);
+	const frontmatter = {};
+	for (const release of releases) if ("cascade" in release && Object.keys(release.cascade).length > 0) frontmatter[release.name] = {
+		bump: release.type,
+		cascade: release.cascade
+	};
+	else frontmatter[release.name] = release.type;
+	await writeText(filePath, `---\n${jsYaml.dump(frontmatter, {
+		lineWidth: -1,
+		quotingType: "\""
+	}).trim()}\n---\n\n${summary}\n`);
+	return filePath;
+}
+/** Delete consumed changeset files */
+async function deleteChangesets(rootDir, ids) {
+	const dir = getBumpyDir(rootDir);
+	for (const id of ids) await removeFile(resolve(dir, `${id}.md`));
+}
+function fileToId(filePath) {
+	return filePath.split("/").pop().replace(/\.md$/, "");
+}
+//#endregion
+export { writeChangeset as i, parseChangeset as n, readChangesets as r, deleteChangesets as t };

package/dist/check-CkRubvuk.mjs

@@ -0,0 +1,57 @@
+import { n as log, t as colorize } from "./logger-ZqggsyGZ.mjs";
+import { a as loadConfig } from "./config-CJ2orhTL.mjs";
+import { n as discoverWorkspace } from "./workspace-mVjawG8g.mjs";
+import { r as readChangesets } from "./changeset-ClCYsChu.mjs";
+import { i as tryRun } from "./shell-DPlltpzb.mjs";
+import { relative } from "node:path";
+//#region src/commands/check.ts
+/**
+* Local check: detect which packages have changed on this branch
+* and verify they have corresponding changesets.
+* Designed for pre-push hooks — no GitHub API needed.
+*/
+async function checkCommand(rootDir) {
+	const config = await loadConfig(rootDir);
+	const { packages } = await discoverWorkspace(rootDir, config);
+	const changesets = await readChangesets(rootDir);
+	const coveredPackages = /* @__PURE__ */ new Set();
+	for (const cs of changesets) for (const release of cs.releases) coveredPackages.add(release.name);
+	const baseBranch = config.baseBranch;
+	const changedFiles = getChangedFiles(rootDir, baseBranch);
+	if (changedFiles.length === 0) {
+		log.info("No changed files detected.");
+		return;
+	}
+	const changedPackages = findChangedPackages(changedFiles, packages, rootDir);
+	if (changedPackages.length === 0) {
+		log.info("No managed packages have changed.");
+		return;
+	}
+	const missing = changedPackages.filter((name) => !coveredPackages.has(name));
+	if (missing.length === 0) {
+		log.success(`All ${changedPackages.length} changed package(s) have changesets.`);
+		return;
+	}
+	log.warn(`${missing.length} changed package(s) missing changesets:\n`);
+	for (const name of missing) console.log(`  ${colorize(name, "yellow")}`);
+	console.log();
+	log.dim("Run `bumpy add` to create a changeset, or `bumpy add --empty` if no release is needed.");
+	process.exit(1);
+}
+/** Get files changed on this branch compared to the base branch */
+function getChangedFiles(rootDir, baseBranch) {
+	const diff = tryRun(`git diff --name-only ${tryRun(`git merge-base HEAD origin/${baseBranch}`, { cwd: rootDir }) || `origin/${baseBranch}`}`, { cwd: rootDir });
+	if (!diff) return [];
+	return diff.split("\n").filter(Boolean);
+}
+/** Map changed files to the packages they belong to */
+function findChangedPackages(changedFiles, packages, rootDir) {
+	const changed = /* @__PURE__ */ new Set();
+	for (const file of changedFiles) for (const [name, pkg] of packages) {
+		const pkgRelDir = relative(rootDir, pkg.dir);
+		if (file.startsWith(pkgRelDir + "/")) changed.add(name);
+	}
+	return [...changed];
+}
+//#endregion
+export { checkCommand };