@varlock/bumpy 0.0.0 → 0.0.1

package/dist/dep-graph-DiLeAhl9.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-DbNNEyzq.mjs

@@ -0,0 +1,51 @@
+import { i as __exportAll } from "./logger-ZqggsyGZ.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 };

package/dist/generate-oOFD9ABC.mjs

@@ -0,0 +1,158 @@
+import { n as log, t as colorize } from "./logger-ZqggsyGZ.mjs";
+import { t as ensureDir } from "./fs-DbNNEyzq.mjs";
+import { a as loadConfig, r as getBumpyDir } from "./config-CJ2orhTL.mjs";
+import { t as discoverPackages } from "./workspace-mVjawG8g.mjs";
+import { i as writeChangeset } from "./changeset-ClCYsChu.mjs";
+import { i as tryRun } from "./shell-DPlltpzb.mjs";
+import { n as slugify, t as randomName } from "./names-C-u50ofE.mjs";
+//#region src/commands/generate.ts
+const BUMP_MAP = {
+	feat: "minor",
+	fix: "patch",
+	perf: "patch",
+	refactor: "patch",
+	docs: "patch",
+	style: "patch",
+	test: "patch",
+	build: "patch",
+	ci: "patch",
+	chore: "patch"
+};
+async function generateCommand(rootDir, opts) {
+	const config = await loadConfig(rootDir);
+	const packages = await discoverPackages(rootDir, config);
+	const from = opts.from || findLastVersionTag(rootDir);
+	if (!from) {
+		log.error("Could not detect last version tag. Use --from <ref> to specify.");
+		process.exit(1);
+	}
+	log.step(`Scanning commits from ${colorize(from, "cyan")}...`);
+	const rawLog = tryRun(`git log ${from}..HEAD --format="%H%n%s%n%b%n---END---"`, { cwd: rootDir });
+	if (!rawLog) {
+		log.info("No commits found since " + from);
+		return;
+	}
+	const conventional = parseGitLog(rawLog).map(parseConventionalCommit).filter((c) => c !== null);
+	if (conventional.length === 0) {
+		log.info("No conventional commits found. Commits must follow the format: type(scope): description");
+		return;
+	}
+	log.dim(`  Found ${conventional.length} conventional commit(s)`);
+	const scopeMap = buildScopeMap(packages, config);
+	const releaseMap = /* @__PURE__ */ new Map();
+	for (const commit of conventional) {
+		const bump = commit.breaking ? "major" : BUMP_MAP[commit.type] || "patch";
+		let pkgNames = [];
+		if (commit.scope) {
+			const resolved = resolveScope(commit.scope, scopeMap, packages);
+			if (resolved.length > 0) pkgNames = resolved;
+			else {
+				log.dim(`  Skipping: unknown scope "${commit.scope}" in: ${commit.description}`);
+				continue;
+			}
+		} else {
+			log.dim(`  Skipping (no scope): ${commit.type}: ${commit.description}`);
+			continue;
+		}
+		for (const name of pkgNames) {
+			const existing = releaseMap.get(name);
+			if (existing) {
+				if (bumpPriority(bump) > bumpPriority(existing.type)) existing.type = bump;
+				existing.messages.push(commit.description);
+			} else releaseMap.set(name, {
+				type: bump,
+				messages: [commit.description]
+			});
+		}
+	}
+	if (releaseMap.size === 0) {
+		log.info("No package bumps detected from conventional commits.");
+		return;
+	}
+	const releases = [];
+	const summaryLines = [];
+	for (const [name, info] of releaseMap) {
+		releases.push({
+			name,
+			type: info.type
+		});
+		for (const msg of info.messages) summaryLines.push(`- ${name}: ${msg}`);
+	}
+	if (opts.dryRun) {
+		log.bold("Would create changeset:");
+		for (const r of releases) console.log(`  ${r.name}: ${colorize(r.type, r.type === "major" ? "red" : r.type === "minor" ? "yellow" : "green")}`);
+		console.log();
+		log.dim("Summary:");
+		for (const line of summaryLines) log.dim(`  ${line}`);
+		return;
+	}
+	await ensureDir(getBumpyDir(rootDir));
+	const filename = opts.name ? slugify(opts.name) : randomName();
+	await writeChangeset(rootDir, filename, releases, summaryLines.join("\n"));
+	log.success(`Created changeset: .bumpy/${filename}.md`);
+	for (const r of releases) log.dim(`  ${r.name}: ${r.type}`);
+}
+/** Parse raw git log output into individual commits */
+function parseGitLog(raw) {
+	const commits = [];
+	const entries = raw.split("---END---").filter((e) => e.trim());
+	for (const entry of entries) {
+		const lines = entry.trim().split("\n");
+		if (lines.length < 2) continue;
+		commits.push({
+			hash: lines[0].trim(),
+			subject: lines[1].trim(),
+			body: lines.slice(2).join("\n").trim()
+		});
+	}
+	return commits;
+}
+/** Parse a commit subject into conventional commit format */
+function parseConventionalCommit(commit) {
+	const match = commit.subject.match(/^(\w+)(!)?(?:\(([^)]+)\))?(!)?\s*:\s*(.+)$/);
+	if (!match) return null;
+	const [, type, bang1, scope, bang2, description] = match;
+	const breaking = !!bang1 || !!bang2 || commit.body.includes("BREAKING CHANGE");
+	return {
+		hash: commit.hash,
+		type: type.toLowerCase(),
+		scope: scope || null,
+		breaking,
+		description: description.trim(),
+		body: commit.body
+	};
+}
+/** Build a map of scope aliases → package names from config and package names */
+function buildScopeMap(packages, _config) {
+	const map = /* @__PURE__ */ new Map();
+	for (const [name, pkg] of packages) {
+		const shortName = name.includes("/") ? name.split("/").pop() : name;
+		if (!map.has(shortName)) map.set(shortName, []);
+		map.get(shortName).push(name);
+		if (!map.has(name)) map.set(name, []);
+		map.get(name).push(name);
+		const dirName = pkg.relativeDir.split("/").pop();
+		if (dirName !== shortName) {
+			if (!map.has(dirName)) map.set(dirName, []);
+			map.get(dirName).push(name);
+		}
+	}
+	return map;
+}
+/** Resolve a scope string to package name(s) */
+function resolveScope(scope, scopeMap, packages) {
+	const mapped = scopeMap.get(scope);
+	if (mapped) return [...new Set(mapped)];
+	for (const [key, value] of scopeMap) if (key.toLowerCase() === scope.toLowerCase()) return [...new Set(value)];
+	if (packages.has(scope)) return [scope];
+	return [];
+}
+function bumpPriority(type) {
+	return type === "major" ? 2 : type === "minor" ? 1 : 0;
+}
+/** Find the most recent version tag in the repo */
+function findLastVersionTag(rootDir) {
+	return tryRun("git describe --tags --abbrev=0 --match \"v*\" 2>/dev/null || git describe --tags --abbrev=0 --match \"*@*\" 2>/dev/null", { cwd: rootDir }) || null;
+}
+//#endregion
+export { generateCommand };

package/dist/index.d.mts

@@ -0,0 +1,254 @@
+//#region src/types.d.ts
+type BumpType = 'major' | 'minor' | 'patch';
+type BumpTypeWithIsolated = BumpType | 'minor-isolated' | 'patch-isolated';
+declare const BUMP_LEVELS: Record<BumpType, number>;
+declare function bumpLevel(type: BumpType): number;
+declare function parseIsolatedBump(type: BumpTypeWithIsolated): {
+  bump: BumpType;
+  isolated: boolean;
+};
+declare function maxBump(a: BumpType | undefined, b: BumpType): BumpType;
+interface DependencyBumpRule {
+  /** What bump level in the dependency triggers propagation */
+  trigger: BumpType | 'none';
+  /** What bump to apply to the dependent */
+  bumpAs: BumpType | 'match';
+}
+declare const DEFAULT_BUMP_RULES: Record<string, DependencyBumpRule>;
+type DepType = 'dependencies' | 'devDependencies' | 'peerDependencies' | 'optionalDependencies';
+declare const DEP_TYPES: DepType[];
+interface PublishConfig {
+  /** Package manager to use for packing. "auto" detects from lockfile. Default: "auto" */
+  packManager: 'auto' | 'npm' | 'pnpm' | 'bun' | 'yarn';
+  /** Command to use for publishing. "npm" uses npm publish (supports OIDC). Default: "npm" */
+  publishManager: 'npm' | 'pnpm' | 'bun' | 'yarn';
+  /** Extra args appended to the publish command (e.g., "--provenance") */
+  publishArgs: string[];
+  /**
+   * How to handle workspace:/catalog: protocol resolution.
+   * "pack" = use PM's pack to build a clean tarball, then publish the tarball (recommended)
+   * "in-place" = resolve protocols by rewriting package.json before publish
+   * "none" = don't resolve (only if PM's publish handles it natively)
+   * Default: "pack"
+   */
+  protocolResolution: 'pack' | 'in-place' | 'none';
+}
+interface BumpyConfig {
+  baseBranch: string;
+  access: 'public' | 'restricted';
+  commit: boolean;
+  changelog: string | [string, Record<string, unknown>];
+  fixed: string[][];
+  linked: string[][];
+  /** Package names/globs to exclude from version management */
+  ignore: string[];
+  /** Package names/globs to explicitly include (overrides private + ignore) */
+  include: string[];
+  updateInternalDependencies: 'patch' | 'minor' | 'out-of-range' | 'none';
+  dependencyBumpRules: Partial<Record<DepType, DependencyBumpRule>>;
+  privatePackages: {
+    version: boolean;
+    tag: boolean;
+  };
+  packages: Record<string, PackageConfig>;
+  publish: PublishConfig;
+  /**
+   * GitHub release creation (requires `gh` CLI).
+   * false = individual release per package (default)
+   * true = single aggregated release for all packages
+   * { enabled: true, title: "..." } = aggregate with custom title (supports {{date}})
+   */
+  aggregateRelease: boolean | {
+    enabled: boolean;
+    title?: string;
+  };
+  /** Git identity used for CI commits. Defaults to bumpy-bot. */
+  gitUser: {
+    name: string;
+    email: string;
+  };
+  /** Version PR settings */
+  versionPr: {
+    /** PR title. Default: "🐸 Versioned release" */title: string; /** Branch name. Default: "bumpy/version-packages" */
+    branch: string; /** Preamble text shown at the top of the PR body */
+    preamble: string;
+  };
+}
+interface PackageConfig {
+  /** Explicitly opt in or out of version management (overrides private/ignore/include) */
+  managed?: boolean;
+  access?: 'public' | 'restricted';
+  publishCommand?: string | string[];
+  buildCommand?: string;
+  registry?: string;
+  skipNpmPublish?: boolean;
+  /** Command to check if a version is already published. Should output the published version string. */
+  checkPublished?: string;
+  dependencyBumpRules?: Partial<Record<DepType, DependencyBumpRule>>;
+  specificDependencyRules?: Record<string, DependencyBumpRule>;
+  cascadeTo?: Record<string, DependencyBumpRule>;
+}
+declare const DEFAULT_PUBLISH_CONFIG: PublishConfig;
+declare const DEFAULT_CONFIG: BumpyConfig;
+interface ChangesetReleaseSimple {
+  name: string;
+  type: BumpTypeWithIsolated;
+}
+interface ChangesetReleaseCascade {
+  name: string;
+  type: BumpTypeWithIsolated;
+  cascade: Record<string, BumpType>;
+}
+type ChangesetRelease = ChangesetReleaseSimple | ChangesetReleaseCascade;
+declare function hasCascade(r: ChangesetRelease): r is ChangesetReleaseCascade;
+interface Changeset {
+  id: string;
+  releases: ChangesetRelease[];
+  summary: string;
+}
+interface WorkspacePackage {
+  name: string;
+  version: string;
+  dir: string;
+  relativeDir: string;
+  packageJson: Record<string, unknown>;
+  private: boolean;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+  peerDependencies: Record<string, string>;
+  optionalDependencies: Record<string, string>;
+  bumpy?: PackageConfig;
+}
+type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+interface DependentInfo {
+  /** The package that depends on the source */
+  name: string;
+  depType: DepType;
+  versionRange: string;
+}
+interface PlannedRelease {
+  name: string;
+  type: BumpType;
+  oldVersion: string;
+  newVersion: string;
+  changesets: string[];
+  isDependencyBump: boolean;
+  isCascadeBump: boolean;
+}
+interface ReleasePlan {
+  changesets: Changeset[];
+  releases: PlannedRelease[];
+}
+//#endregion
+//#region src/core/config.d.ts
+/** Find the monorepo root by walking up from cwd looking for .bumpy/ */
+declare function findRoot(startDir?: string): Promise<string>;
+/** Load the root bumpy config, merging with defaults */
+declare function loadConfig(rootDir: string): Promise<BumpyConfig>;
+/** Simple glob matching for package names (supports * and **) */
+declare function matchGlob(name: string, pattern: string): boolean;
+declare function getBumpyDir(rootDir: string): string;
+//#endregion
+//#region src/utils/package-manager.d.ts
+/** Map of catalog name → { depName → version }. Default catalog uses "" as key. */
+type CatalogMap = Map<string, Record<string, string>>;
+//#endregion
+//#region src/core/workspace.d.ts
+/** Convenience wrapper that returns just packages (backwards compat) */
+declare function discoverPackages(rootDir: string, config: BumpyConfig): Promise<Map<string, WorkspacePackage>>;
+//#endregion
+//#region src/core/dep-graph.d.ts
+declare class DependencyGraph {
+  /** Map from package name → packages that depend on it */
+  private dependents;
+  /** Set of all internal package names */
+  private internalPackages;
+  constructor(packages: Map<string, WorkspacePackage>);
+  private build;
+  /** Get all packages that depend on the given package */
+  getDependents(pkgName: string): DependentInfo[];
+  /** Check if a package is an internal workspace package */
+  isInternal(pkgName: string): boolean;
+  /** Get all internal package names */
+  allPackages(): string[];
+  /** Topological sort — returns packages in dependency order (deps first) */
+  topologicalSort(packages: Map<string, WorkspacePackage>): string[];
+}
+//#endregion
+//#region src/core/changeset.d.ts
+/** Read all changeset files from .bumpy/ directory */
+declare function readChangesets(rootDir: string): Promise<Changeset[]>;
+/** Parse changeset content (for testing) */
+declare function parseChangeset(content: string, id: string): Changeset | null;
+/** Write a changeset file */
+declare function writeChangeset(rootDir: string, filename: string, releases: ChangesetRelease[], summary: string): Promise<string>;
+//#endregion
+//#region src/core/release-plan.d.ts
+/**
+ * Build a release plan from pending changesets, the dependency graph, and config.
+ * This is the core algorithm of bumpy.
+ */
+declare function assembleReleasePlan(changesets: Changeset[], packages: Map<string, WorkspacePackage>, depGraph: DependencyGraph, config: BumpyConfig): ReleasePlan;
+//#endregion
+//#region src/core/apply-release-plan.d.ts
+/** Apply the release plan: bump versions, update changelogs, delete changesets */
+declare function applyReleasePlan(releasePlan: ReleasePlan, packages: Map<string, WorkspacePackage>, rootDir: string, config: BumpyConfig): Promise<void>;
+//#endregion
+//#region src/core/changelog.d.ts
+interface ChangelogContext {
+  release: PlannedRelease;
+  /** Changesets that contributed to this release */
+  changesets: Changeset[];
+  /** ISO date string (YYYY-MM-DD) */
+  date: string;
+}
+/**
+ * A changelog formatter receives full context and returns the complete
+ * changelog entry string for a single release.
+ */
+type ChangelogFormatter = (ctx: ChangelogContext) => string | Promise<string>;
+/** Default formatter — version heading, date, bullet points */
+declare const defaultFormatter: ChangelogFormatter;
+/**
+ * Load a changelog formatter from config.
+ * Supports: "default", "./path/to/formatter.ts", or a module name.
+ */
+declare function loadFormatter(changelog: BumpyConfig['changelog'], rootDir: string): Promise<ChangelogFormatter>;
+/** Generate a changelog entry using the configured formatter */
+declare function generateChangelogEntry(release: PlannedRelease, changesets: Changeset[], formatter?: ChangelogFormatter, date?: string): Promise<string>;
+/** Prepend a new entry to an existing CHANGELOG.md content */
+declare function prependToChangelog(existingContent: string, newEntry: string): string;
+//#endregion
+//#region src/core/semver.d.ts
+declare function bumpVersion(version: string, type: BumpType): string;
+/** Check if a version satisfies a range */
+declare function satisfies(version: string, range: string): boolean;
+/** Strip workspace: protocol from version ranges */
+declare function stripProtocol(range: string): string;
+//#endregion
+//#region src/core/publish-pipeline.d.ts
+interface PublishOptions {
+  dryRun?: boolean;
+  tag?: string;
+}
+interface PublishResult {
+  published: {
+    name: string;
+    version: string;
+  }[];
+  skipped: {
+    name: string;
+    reason: string;
+  }[];
+  failed: {
+    name: string;
+    error: string;
+  }[];
+}
+/**
+ * Publish all packages in the release plan.
+ * Order: topological (dependencies published before dependents).
+ */
+declare function publishPackages(releasePlan: ReleasePlan, packages: Map<string, WorkspacePackage>, depGraph: DependencyGraph, config: BumpyConfig, rootDir: string, opts?: PublishOptions, catalogs?: CatalogMap, detectedPm?: PackageManager): Promise<PublishResult>;
+//#endregion
+export { BUMP_LEVELS, BumpType, BumpTypeWithIsolated, BumpyConfig, type ChangelogContext, type ChangelogFormatter, Changeset, ChangesetRelease, ChangesetReleaseCascade, ChangesetReleaseSimple, DEFAULT_BUMP_RULES, DEFAULT_CONFIG, DEFAULT_PUBLISH_CONFIG, DEP_TYPES, DepType, DependencyBumpRule, DependencyGraph, DependentInfo, PackageConfig, PackageManager, PlannedRelease, PublishConfig, ReleasePlan, WorkspacePackage, applyReleasePlan, assembleReleasePlan, bumpLevel, bumpVersion, defaultFormatter, discoverPackages, findRoot, generateChangelogEntry, getBumpyDir, hasCascade, loadConfig, loadFormatter, matchGlob, maxBump, parseChangeset, parseIsolatedBump, prependToChangelog, publishPackages, readChangesets, satisfies, stripProtocol, writeChangeset };

package/dist/index.mjs

@@ -0,0 +1,9 @@
+import { a as loadConfig, c as BUMP_LEVELS, d as DEFAULT_PUBLISH_CONFIG, f as DEP_TYPES, g as parseIsolatedBump, h as maxBump, l as DEFAULT_BUMP_RULES, m as hasCascade, n as findRoot, p as bumpLevel, r as getBumpyDir, s as matchGlob, u as DEFAULT_CONFIG } 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, n as parseChangeset, r as readChangesets } from "./changeset-ClCYsChu.mjs";
+import { n as satisfies, r as stripProtocol, t as bumpVersion } from "./semver-DWO6NFKN.mjs";
+import { t as assembleReleasePlan } from "./release-plan-CFnutSHD.mjs";
+import { a as prependToChangelog, i as loadFormatter, n as defaultFormatter, r as generateChangelogEntry, t as applyReleasePlan } from "./apply-release-plan-DtU3rVyL.mjs";
+import { t as publishPackages } from "./publish-pipeline-1M5GmbdP.mjs";
+export { BUMP_LEVELS, DEFAULT_BUMP_RULES, DEFAULT_CONFIG, DEFAULT_PUBLISH_CONFIG, DEP_TYPES, DependencyGraph, applyReleasePlan, assembleReleasePlan, bumpLevel, bumpVersion, defaultFormatter, discoverPackages, findRoot, generateChangelogEntry, getBumpyDir, hasCascade, loadConfig, loadFormatter, matchGlob, maxBump, parseChangeset, parseIsolatedBump, prependToChangelog, publishPackages, readChangesets, satisfies, stripProtocol, writeChangeset };

package/dist/init-Blw2GfC_.mjs

@@ -0,0 +1,22 @@
+import { n as log } from "./logger-ZqggsyGZ.mjs";
+import { c as writeJson, l as writeText, n as exists, t as ensureDir } from "./fs-DbNNEyzq.mjs";
+import { resolve } from "node:path";
+//#region src/commands/init.ts
+async function initCommand(rootDir) {
+	const bumpyDir = resolve(rootDir, ".bumpy");
+	if (await exists(resolve(bumpyDir, "_config.json"))) {
+		log.warn(".bumpy/_config.json already exists");
+		return;
+	}
+	await ensureDir(bumpyDir);
+	await writeJson(resolve(bumpyDir, "_config.json"), {
+		baseBranch: "main",
+		changelog: "default"
+	});
+	await writeText(resolve(bumpyDir, "README.md"), `# 🐸 Bumpy\n\nThis directory is used by [bumpy](https://github.com/dmno-dev/bumpy) to manage versioning.\n\nChangeset files (\`.md\`) in this directory describe pending version bumps.\nRun \`bumpy add\` to create a new changeset.\n`);
+	log.success("Initialized .bumpy/ directory");
+	log.dim("  Created .bumpy/_config.json");
+	log.dim("  Created .bumpy/README.md");
+}
+//#endregion
+export { initCommand };