@varlock/bumpy 0.0.0 → 0.0.2

package/dist/generate-Btrsn1qi.mjs

@@ -0,0 +1,177 @@
+import { n as log, t as colorize } from "./logger-C2dEe5Su.mjs";
+import { t as ensureDir } from "./fs-0AtnPUUe.mjs";
+import { a as loadConfig, r as getBumpyDir } from "./config-BkwIEaQg.mjs";
+import { t as discoverPackages } from "./workspace-CxEKakDm.mjs";
+import { o as tryRunArgs } from "./shell-Dj7JRD_q.mjs";
+import { i as writeChangeset } from "./changeset-UCZdSRDv.mjs";
+import { n as slugify, t as randomName } from "./names-Ck8cun7B.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 = tryRunArgs([
+		"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 tryRunArgs([
+		"git",
+		"describe",
+		"--tags",
+		"--abbrev=0",
+		"--match",
+		"v*"
+	], { cwd: rootDir }) || tryRunArgs([
+		"git",
+		"describe",
+		"--tags",
+		"--abbrev=0",
+		"--match",
+		"*@*"
+	], { cwd: rootDir }) || null;
+}
+//#endregion
+export { generateCommand };

package/dist/git-CGHVXXKw.mjs

@@ -0,0 +1,78 @@
+import { o as tryRunArgs, t as runArgs } from "./shell-Dj7JRD_q.mjs";
+//#region src/core/git.ts
+/** Create a git tag */
+function createTag(tag, opts) {
+	runArgs([
+		"git",
+		"tag",
+		tag
+	], opts);
+}
+/** Push commits and tags to remote */
+function pushWithTags(opts) {
+	runArgs(["git", "push"], opts);
+	runArgs([
+		"git",
+		"push",
+		"--tags"
+	], opts);
+}
+/** Check if there are uncommitted changes */
+function hasUncommittedChanges(opts) {
+	const result = tryRunArgs([
+		"git",
+		"status",
+		"--porcelain"
+	], opts);
+	return result !== null && result.length > 0;
+}
+/** Check if a tag already exists */
+function tagExists(tag, opts) {
+	return tryRunArgs([
+		"git",
+		"tag",
+		"-l",
+		tag
+	], opts) === tag;
+}
+/** Get files changed on this branch compared to a base branch */
+function getChangedFiles(rootDir, baseBranch) {
+	if (!tryRunArgs([
+		"git",
+		"rev-parse",
+		"--verify",
+		`origin/${baseBranch}`
+	], { cwd: rootDir })) tryRunArgs([
+		"git",
+		"fetch",
+		"origin",
+		baseBranch,
+		"--depth=1"
+	], { cwd: rootDir });
+	const diff = tryRunArgs([
+		"git",
+		"diff",
+		"--name-only",
+		tryRunArgs([
+			"git",
+			"merge-base",
+			"HEAD",
+			`origin/${baseBranch}`
+		], { cwd: rootDir }) || `origin/${baseBranch}`
+	], { cwd: rootDir });
+	if (!diff) return [];
+	return diff.split("\n").filter(Boolean);
+}
+/** Get all tags matching a pattern */
+function listTags(pattern, opts) {
+	const result = tryRunArgs([
+		"git",
+		"tag",
+		"-l",
+		pattern
+	], opts);
+	if (!result) return [];
+	return result.split("\n").filter(Boolean);
+}
+//#endregion
+export { pushWithTags as a, listTags as i, getChangedFiles as n, tagExists as o, hasUncommittedChanges as r, createTag as t };

package/dist/index.d.mts

@@ -0,0 +1,262 @@
+//#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, sorted by git creation order */
+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/changelog-github.d.ts
+interface GithubChangelogOptions {
+  /** "owner/repo" — auto-detected from gh CLI if not provided */
+  repo?: string;
+  /** GitHub usernames (without @) to skip "Thanks" messages for (e.g. internal team members) */
+  internalAuthors?: 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, type GithubChangelogOptions, 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-BkwIEaQg.mjs";
+import { t as discoverPackages } from "./workspace-CxEKakDm.mjs";
+import { t as DependencyGraph } from "./dep-graph-E-9-eQ2J.mjs";
+import { i as writeChangeset, n as parseChangeset, r as readChangesets } from "./changeset-UCZdSRDv.mjs";
+import { n as satisfies, r as stripProtocol, t as bumpVersion } from "./semver-BTzYh8vc.mjs";
+import { t as assembleReleasePlan } from "./release-plan-BEzwApuK.mjs";
+import { a as prependToChangelog, i as loadFormatter, n as defaultFormatter, r as generateChangelogEntry, t as applyReleasePlan } from "./apply-release-plan-D6TSrcwX.mjs";
+import { t as publishPackages } from "./publish-pipeline-ChnqW8nR.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-B0q3wEQW.mjs

@@ -0,0 +1,22 @@
+import { n as log } from "./logger-C2dEe5Su.mjs";
+import { c as writeJson, l as writeText, n as exists, t as ensureDir } from "./fs-0AtnPUUe.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 };