@varlock/bumpy 0.0.1 → 1.0.0

package/dist/shell-DPlltpzb.mjs

@@ -1,44 +0,0 @@
-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/version-CJwf8XIA.mjs

@@ -1,81 +0,0 @@
-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

@@ -1,183 +0,0 @@
-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 };