aronrepo 2.2.1 → 3.0.0

package/dist/commands-CO26JPbK.js

@@ -0,0 +1,1170 @@
+import { agentsBlockEnd, agentsBlockStart, commits, createReleasePathMatcher, defaultReleasePathExcludes, getAgentCommitPolicy, getBaseTag, getNextVersion, getReleaseChannel, getReleasePolicy, getReleaseTable, getReleaseType, legacyCommits, parseCommit, renderAgentsBlock, renderReleaseNotes, resolveCommitRelease, resolveRelease, toVersionTag } from "./index.js";
+import { execFileSync, spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { globSync } from "tinyglobby";
+import { load } from "js-yaml";
+import os from "node:os";
+import { gunzipSync } from "node:zlib";
+// src/project.ts
+const configFileNames = ["aronrepo.config.js", "aronrepo.config.mjs"];
+function toPosixPath(value) {
+	return value.split(path.sep).join("/");
+}
+function readJson$1(file) {
+	return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+function findConfigFile(cwd = process.cwd()) {
+	return configFileNames.map((name) => path.join(cwd, name)).find((file) => fs.existsSync(file));
+}
+/** Loads `aronrepo.config.js` from the repository root; returns `{}` when it is missing. */
+async function loadConfig(cwd = process.cwd()) {
+	const file = findConfigFile(cwd);
+	if (!file) return {};
+	const stat = fs.statSync(file);
+	return (await import(`${pathToFileURL(file).href}?mtime=${stat.mtimeMs}&size=${stat.size}`)).default ?? {};
+}
+function readPNPMWorkspaces(cwd) {
+	const workspacePath = path.join(cwd, "pnpm-workspace.yaml");
+	if (!fs.existsSync(workspacePath)) return void 0;
+	return load(fs.readFileSync(workspacePath, "utf8"))?.packages;
+}
+function readNPMWorkspaces(cwd) {
+	const packagePath = path.join(cwd, "package.json");
+	if (!fs.existsSync(packagePath)) return void 0;
+	const pkg = readJson$1(packagePath);
+	return Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
+}
+function readWorkspacePatterns(cwd = process.cwd()) {
+	return readPNPMWorkspaces(cwd) ?? readNPMWorkspaces(cwd) ?? [];
+}
+function queryWorkspaceDirs(patterns, cwd = process.cwd()) {
+	if (!patterns.length) return [];
+	return globSync(patterns.map((workspace) => `${workspace}/package.json`), {
+		cwd,
+		onlyFiles: true,
+		expandDirectories: false,
+		ignore: ["**/node_modules/**"]
+	}).map((workspacePackage) => toPosixPath(workspacePackage).replace(/\/?package\.json$/, "") || ".").sort();
+}
+function readWorkspacePackage(cwd, workspace) {
+	return readJson$1(path.join(cwd, workspace, "package.json"));
+}
+/** Workspace directories whose package is published to npm. */
+function queryPublicWorkspaceDirs(cwd = process.cwd()) {
+	return queryWorkspaceDirs(readWorkspacePatterns(cwd), cwd).filter((workspace) => readWorkspacePackage(cwd, workspace).publishConfig?.access === "public");
+}
+/**
+* Resolves the files whose changes can release a version.
+*
+* Configured paths win. Otherwise public workspace packages define them; a
+* single-package repository with a non-private root package uses every path.
+* Returns `undefined` when no published package is found, which turns the check off.
+*/
+function resolveReleasePaths(cwd = process.cwd(), policy) {
+	if (policy?.paths === false) return void 0;
+	if (policy?.paths?.include) return {
+		include: policy.paths.include,
+		exclude: policy.paths.exclude ?? defaultReleasePathExcludes
+	};
+	const exclude = policy?.paths?.exclude ?? defaultReleasePathExcludes;
+	const publicWorkspaces = queryPublicWorkspaceDirs(cwd);
+	if (publicWorkspaces.length) return {
+		include: publicWorkspaces.map((dir) => dir === "." ? "**" : `${dir}/**`),
+		exclude
+	};
+	const rootPackage = path.join(cwd, "package.json");
+	if (!readWorkspacePatterns(cwd).length && fs.existsSync(rootPackage) && !readJson$1(rootPackage).private) return {
+		include: ["**"],
+		exclude
+	};
+}
+const lockfiles = [
+	["bun.lock", "bun"],
+	["bun.lockb", "bun"],
+	["pnpm-lock.yaml", "pnpm"],
+	["pnpm-workspace.yaml", "pnpm"],
+	["yarn.lock", "yarn"],
+	["package-lock.json", "npm"]
+];
+/** The package manager from `packageManager` in package.json, then from the lockfile; `npm` by default. */
+function detectPackageManager(cwd = process.cwd()) {
+	const rootPackage = path.join(cwd, "package.json");
+	const declared = fs.existsSync(rootPackage) ? String(readJson$1(rootPackage).packageManager ?? "").split("@")[0] : "";
+	if (declared === "bun" || declared === "pnpm" || declared === "yarn" || declared === "npm") return declared;
+	return lockfiles.find(([file]) => fs.existsSync(path.join(cwd, file)))?.[1] ?? "npm";
+}
+/** How to run the aronrepo CLI with a package manager. */
+function getCliCommand(packageManager) {
+	return {
+		bun: "bun x aronrepo",
+		pnpm: "pnpm exec aronrepo",
+		yarn: "yarn aronrepo",
+		npm: "npx aronrepo"
+	}[packageManager];
+}
+/**
+* How to run the aronrepo CLI in a repository: its `aronrepo` script when it has
+* one, for example a workspace that builds aronrepo itself, or the installed binary.
+*/
+function getProjectCliCommand(cwd, packageManager = detectPackageManager(cwd)) {
+	const rootPackage = path.join(cwd, "package.json");
+	if ((fs.existsSync(rootPackage) ? readJson$1(rootPackage).scripts : void 0)?.aronrepo) return packageManager === "npm" ? "npm run aronrepo --" : `${packageManager} run aronrepo`;
+	return getCliCommand(packageManager);
+}
+/** Loads the config, release policy, and release paths of a repository. */
+async function loadProjectPolicy(cwd = process.cwd(), overrides = {}) {
+	const config = await loadConfig(cwd);
+	const policy = {
+		...getReleasePolicy(config),
+		...overrides
+	};
+	const releasePaths = resolveReleasePaths(cwd, policy);
+	const configFile = findConfigFile(cwd);
+	const packageManager = detectPackageManager(cwd);
+	return {
+		cwd,
+		packageManager,
+		cli: getProjectCliCommand(cwd, packageManager),
+		config,
+		...configFile ? { configFile } : {},
+		policy,
+		...releasePaths ? { releasePaths } : {},
+		...releasePaths ? { isReleasePath: createReleasePathMatcher(releasePaths) } : {}
+	};
+}
+function git$1(cwd, args) {
+	return execFileSync("git", args, {
+		cwd,
+		encoding: "utf8",
+		maxBuffer: 67108864
+	});
+}
+function splitLines(output) {
+	return output.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+/** Files changed by one commit. Merge commits report no files. */
+function getCommitFiles(cwd, hash) {
+	return splitLines(git$1(cwd, [
+		"diff-tree",
+		"--no-commit-id",
+		"--name-only",
+		"-r",
+		"--root",
+		hash
+	]));
+}
+function getStagedFiles(cwd = process.cwd()) {
+	return splitLines(git$1(cwd, [
+		"diff",
+		"--cached",
+		"--name-only"
+	]));
+}
+/** Files changed between the merge base of `base` and `head`, like a pull request diff. */
+function getDiffFiles(cwd, base, head) {
+	return splitLines(git$1(cwd, [
+		"diff",
+		"--name-only",
+		`${base}...${head}`
+	]));
+}
+/** Commits in `from..to`, oldest first, with their changed files. */
+function getRangeCommits(cwd, from, to = "HEAD") {
+	return git$1(cwd, [
+		"log",
+		"--reverse",
+		"--format=%H%x1f%B%x1e",
+		from ? `${from}..${to}` : to
+	]).split("").map((entry) => entry.replace(/^\n/, "")).filter((entry) => entry.includes("")).map((entry) => {
+		const [hash, message] = entry.split("");
+		return {
+			hash,
+			message: message.trim(),
+			files: getCommitFiles(cwd, hash)
+		};
+	});
+}
+/** Latest tag reachable from `ref`, or `undefined` when there is none. */
+function getLatestTag(cwd, ref = "HEAD") {
+	try {
+		return git$1(cwd, [
+			"describe",
+			"--tags",
+			"--abbrev=0",
+			ref
+		]).trim() || void 0;
+	} catch {
+		return;
+	}
+}
+/** Resolves the release of a commit range with the repository's policy and release paths. */
+async function explainRange(cwd, from, to = "HEAD", overrides = {}) {
+	const project = await loadProjectPolicy(cwd, overrides);
+	const commits = getRangeCommits(cwd, from, to);
+	return {
+		...project,
+		from,
+		to,
+		...resolveRelease(commits, project.policy, project.isReleasePath ? { isReleasePath: project.isReleasePath } : {})
+	};
+}
+// src/release.ts
+const officialRegistry = "https://registry.npmjs.org/";
+/** npm dist-tag that holds a release until every package of it is published. */
+const stagingDistTag = "aronrepo-staging";
+/** GitHub rejects release bodies over 125,000 characters. */
+const releaseBodyLimit = 12e4;
+const runCommand = (command, args, { cwd, env }) => new Promise((resolve, reject) => {
+	const child = spawn(command, args, {
+		cwd,
+		env,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		shell: process.platform === "win32"
+	});
+	let stdout = "";
+	let stderr = "";
+	child.stdout.on("data", (chunk) => {
+		stdout += chunk;
+	});
+	child.stderr.on("data", (chunk) => {
+		stderr += chunk;
+	});
+	child.on("error", reject);
+	child.on("close", (code) => {
+		if (code === 0) resolve({
+			stdout,
+			stderr
+		});
+		else reject(/* @__PURE__ */ new Error(`\`${command} ${args.join(" ")}\` exited with ${code}.\n${stderr.trim() || stdout.trim()}`));
+	});
+});
+function createEnvironment(options = {}) {
+	return {
+		cwd: options.cwd ?? process.cwd(),
+		env: options.env ?? process.env,
+		run: options.run ?? runCommand,
+		fetch: options.fetch ?? ((input, init) => fetch(input, init)),
+		log: options.log ?? ((message) => console.log(message)),
+		wait: options.wait ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)))
+	};
+}
+async function git(environment, args) {
+	return (await environment.run("git", args, {
+		cwd: environment.cwd,
+		env: environment.env
+	})).stdout.trim();
+}
+function lines(output) {
+	return output.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function readJson(file) {
+	return JSON.parse(fs.readFileSync(file, "utf8"));
+}
+const dependencyFields = [
+	"dependencies",
+	"optionalDependencies",
+	"peerDependencies"
+];
+/** Published packages of the repository in dependency order. */
+function getReleasePackages(cwd) {
+	let dirs = queryPublicWorkspaceDirs(cwd);
+	if (!dirs.length && !readWorkspacePatterns(cwd).length) {
+		const root = path.join(cwd, "package.json");
+		if (fs.existsSync(root) && !readJson(root).private) dirs = ["."];
+	}
+	const packages = dirs.map((dir) => {
+		const manifest = readJson(path.join(cwd, dir, "package.json"));
+		if (!manifest.name) throw new Error(`${dir}/package.json has no name.`);
+		return {
+			dir,
+			name: manifest.name,
+			manifest
+		};
+	});
+	const names = new Set(packages.map(({ name }) => name));
+	const dependenciesOf = (pkg) => dependencyFields.flatMap((field) => Object.keys(pkg.manifest[field] ?? {})).filter((name) => names.has(name) && name !== pkg.name);
+	const ordered = [];
+	const visiting = /* @__PURE__ */ new Set();
+	const visit = (pkg) => {
+		if (ordered.includes(pkg)) return;
+		if (visiting.has(pkg.name)) throw new Error(`Published packages depend on each other in a cycle through ${pkg.name}.`);
+		visiting.add(pkg.name);
+		for (const name of dependenciesOf(pkg)) visit(packages.find((candidate) => candidate.name === name));
+		visiting.delete(pkg.name);
+		ordered.push(pkg);
+	};
+	for (const pkg of [...packages].sort((a, b) => a.dir.localeCompare(b.dir))) visit(pkg);
+	return ordered;
+}
+/** The repository URL on GitHub, from `GITHUB_REPOSITORY` or the root package.json. */
+function getRepositoryUrl(cwd, env = process.env) {
+	if (env.GITHUB_REPOSITORY) return `${env.GITHUB_SERVER_URL ?? "https://github.com"}/${env.GITHUB_REPOSITORY}`;
+	const root = path.join(cwd, "package.json");
+	if (!fs.existsSync(root)) return void 0;
+	const repository = readJson(root).repository;
+	const url = typeof repository === "string" ? repository : repository?.url;
+	const match = url && /github\.com[/:]([^/]+\/[^/.]+?)(?:\.git)?\/?$/.exec(url);
+	return match ? `https://github.com/${match[1]}` : void 0;
+}
+async function getBranch(environment, branch) {
+	return branch ?? environment.env.GITHUB_REF_NAME ?? await git(environment, [
+		"rev-parse",
+		"--abbrev-ref",
+		"HEAD"
+	]);
+}
+/** Plans the next release of the checked-out commit without changing anything. */
+async function planRelease(options = {}, environmentOptions = {}) {
+	const environment = createEnvironment(environmentOptions);
+	const { cwd } = environment;
+	const project = await loadProjectPolicy(cwd, options.mode ? { mode: options.mode } : {});
+	const branch = await getBranch(environment, options.branch);
+	const channel = getReleaseChannel(branch) ?? (options.fallbackToMain ? getReleaseChannel("main") : void 0);
+	const head = await git(environment, ["rev-parse", "HEAD"]);
+	const ignored = new Set(options.ignoreTags ?? []);
+	const reachable = lines(await git(environment, [
+		"tag",
+		"--list",
+		"v*",
+		"--merged",
+		"HEAD"
+	])).filter((tag) => !ignored.has(tag));
+	const all = lines(await git(environment, [
+		"tag",
+		"--list",
+		"v*"
+	])).filter((tag) => !ignored.has(tag));
+	const packages = getReleasePackages(cwd);
+	const base = {
+		branch,
+		head,
+		mode: project.policy.mode,
+		release: false,
+		commits: [],
+		packages
+	};
+	if (!channel) return base;
+	const from = getBaseTag(channel, reachable);
+	const decision = resolveRelease(getRangeCommits(cwd, from, "HEAD"), project.policy, project.isReleasePath ? { isReleasePath: project.isReleasePath } : {});
+	const plan = {
+		...base,
+		channel,
+		...from ? { from } : {},
+		release: decision.release,
+		commits: decision.commits
+	};
+	if (!decision.release) return plan;
+	const version = getNextVersion(channel, decision.release, {
+		reachable,
+		all
+	});
+	const repositoryUrl = getRepositoryUrl(cwd, environment.env);
+	return {
+		...plan,
+		version,
+		tag: toVersionTag(version),
+		notes: renderReleaseNotes({
+			version,
+			...from ? { previousTag: from } : {},
+			date: options.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+			...repositoryUrl ? { repositoryUrl } : {},
+			commits: decision.commits
+		})
+	};
+}
+/** Registry of a package: its scoped registry, `publishConfig.registry`, `NPM_CONFIG_REGISTRY`, then npm. */
+function getRegistry(manifest, env = process.env) {
+	const scope = manifest.name?.startsWith("@") ? manifest.name.split("/")[0] : void 0;
+	const configured = (scope ? manifest.publishConfig?.[`${scope}:registry`] : void 0) ?? manifest.publishConfig?.registry ?? env.NPM_CONFIG_REGISTRY;
+	const registry = typeof configured === "string" && configured ? configured : officialRegistry;
+	return registry.endsWith("/") ? registry : `${registry}/`;
+}
+function nerfDart(registry) {
+	const url = new URL(registry);
+	return `//${url.host}${url.pathname.endsWith("/") ? url.pathname : `${url.pathname}/`}`;
+}
+async function readPackument(environment, registry, name) {
+	const response = await environment.fetch(`${registry}${name.replace("/", "%2f")}`, { headers: {
+		accept: "application/json",
+		"cache-control": "no-cache"
+	} });
+	if (response.status === 404) return void 0;
+	if (!response.ok) throw new Error(`Could not read ${name} from ${registry}: ${response.status} ${response.statusText}`);
+	return await response.json();
+}
+async function getGitHubIdToken(environment, audience) {
+	const { ACTIONS_ID_TOKEN_REQUEST_URL: url, ACTIONS_ID_TOKEN_REQUEST_TOKEN: token } = environment.env;
+	if (!url || !token) return void 0;
+	const response = await environment.fetch(`${url}${url.includes("?") ? "&" : "?"}audience=${encodeURIComponent(audience)}`, { headers: {
+		authorization: `Bearer ${token}`,
+		accept: "application/json"
+	} });
+	if (!response.ok) {
+		environment.log(`! Could not get a GitHub Actions OIDC token: ${response.status} ${response.statusText}`);
+		return;
+	}
+	return (await response.json()).value;
+}
+/** Exchanges a GitHub Actions OIDC token for a short-lived npm publish token (npm trusted publishing). */
+async function exchangeOidcToken(environment, name, registry) {
+	if (registry !== "https://registry.npmjs.org/") return void 0;
+	const identity = environment.env.NPM_ID_TOKEN ?? await getGitHubIdToken(environment, "npm:registry.npmjs.org");
+	if (!identity) return void 0;
+	const response = await environment.fetch(`${officialRegistry}-/npm/v1/oidc/token/exchange/package/${encodeURIComponent(name)}`, {
+		method: "POST",
+		headers: { authorization: `Bearer ${identity}` }
+	});
+	if (!response.ok) {
+		environment.log(`! Could not exchange the OIDC token for ${name}: ${response.status} ${response.statusText}`);
+		return;
+	}
+	return (await response.json()).token;
+}
+function readNpmrc(file) {
+	return fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+}
+function hasRegistryAuth(content, registry) {
+	const nerfed = nerfDart(registry);
+	return content.split(/\r?\n/).some((line) => {
+		const key = line.split("=")[0].trim();
+		return key === "_authToken" || key === "_auth" || key.startsWith(`${nerfed}:_auth`);
+	});
+}
+/**
+* npm environment for one package: existing `.npmrc` auth, then npm trusted
+* publishing through GitHub Actions OIDC, then `NPM_TOKEN`.
+*/
+async function createNpmEnv(environment, name, registry, directory) {
+	const userconfig = environment.env.NPM_CONFIG_USERCONFIG ?? path.join(os.homedir(), ".npmrc");
+	if (hasRegistryAuth([readNpmrc(path.join(environment.cwd, ".npmrc")), readNpmrc(userconfig)].join("\n"), registry)) return environment.env;
+	const token = await exchangeOidcToken(environment, name, registry) ?? environment.env.NPM_TOKEN;
+	if (!token) throw new Error(`No npm auth for ${name}. Configure npm trusted publishing with \`id-token: write\`, set NPM_TOKEN, or add auth to .npmrc for ${registry}.`);
+	const file = path.join(directory, `${name.replace(/[@/]/g, "_")}.npmrc`);
+	fs.writeFileSync(file, `${readNpmrc(userconfig).trim()}\n${nerfDart(registry)}:_authToken=${token}\n`, { mode: 384 });
+	return {
+		...environment.env,
+		NPM_CONFIG_USERCONFIG: file
+	};
+}
+function detectIndent(content) {
+	return /^(\s+)"/m.exec(content)?.[1] ?? "    ";
+}
+/** Writes the release version and git head into a package manifest. */
+function writeReleaseManifest(cwd, dir, version, gitHead) {
+	const file = path.join(cwd, dir, "package.json");
+	const content = fs.readFileSync(file, "utf8");
+	const manifest = JSON.parse(content);
+	manifest.version = version;
+	manifest.gitHead = gitHead;
+	fs.writeFileSync(file, `${JSON.stringify(manifest, null, detectIndent(content))}\n`);
+	return manifest;
+}
+function packCommand(packageManager, destination) {
+	switch (packageManager) {
+		case "bun": return ["bun", [
+			"pm",
+			"pack",
+			"--destination",
+			destination,
+			"--quiet"
+		]];
+		case "pnpm": return ["pnpm", [
+			"pack",
+			"--pack-destination",
+			destination
+		]];
+		case "yarn": return ["yarn", [
+			"pack",
+			"--out",
+			path.join(destination, "package.tgz")
+		]];
+		default: return ["npm", [
+			"pack",
+			"--pack-destination",
+			destination
+		]];
+	}
+}
+/** Reads `package/package.json` from a packed tarball. */
+function readPackedManifest(tarball) {
+	const archive = gunzipSync(fs.readFileSync(tarball));
+	let offset = 0;
+	let longName;
+	while (offset + 512 <= archive.length) {
+		const header = archive.subarray(offset, offset + 512);
+		if (header.every((byte) => byte === 0)) break;
+		const field = (start, length) => header.subarray(start, start + length).toString("utf8").replace(/\0.*$/s, "");
+		const size = parseInt(field(124, 12).trim() || "0", 8);
+		const type = field(156, 1);
+		const prefix = field(345, 155);
+		const name = longName ?? (prefix ? `${prefix}/${field(0, 100)}` : field(0, 100));
+		const body = archive.subarray(offset + 512, offset + 512 + size);
+		longName = void 0;
+		if (type === "L") longName = body.toString("utf8").replace(/\0.*$/s, "");
+		else if (type === "x") {
+			const pathRecord = /\d+ path=([^\n]+)\n/.exec(body.toString("utf8"));
+			if (pathRecord) longName = pathRecord[1];
+		} else if (name.replace(/^\.\//, "").split("/").slice(1).join("/") === "package.json") return JSON.parse(body.toString("utf8"));
+		offset += 512 + Math.ceil(size / 512) * 512;
+	}
+	throw new Error(`${tarball} has no package.json.`);
+}
+function validatePackedManifest(manifest, pkg, version, gitHead) {
+	if (manifest.name !== pkg.name) throw new Error(`The tarball of ${pkg.dir} is ${manifest.name}, not ${pkg.name}.`);
+	if (manifest.version !== version) throw new Error(`The tarball of ${pkg.name} has version ${manifest.version}, not ${version}.`);
+	if (manifest.gitHead !== gitHead) throw new Error(`The tarball of ${pkg.name} has gitHead ${String(manifest.gitHead)}, not ${gitHead}.`);
+	for (const field of dependencyFields) for (const [name, range] of Object.entries(manifest[field] ?? {})) if (range.startsWith("workspace:")) throw new Error(`The tarball of ${pkg.name} keeps \`${name}: ${range}\` in ${field}.`);
+}
+async function waitForVersion(environment, registry, name, version) {
+	for (let attempt = 1; attempt <= 30; attempt++) {
+		const published = (await readPackument(environment, registry, name))?.versions?.[version];
+		if (published) return published;
+		await environment.wait(1e4);
+	}
+	throw new Error(`${name}@${version} did not appear on ${registry}.`);
+}
+function truncateNotes(notes, url) {
+	if (notes.length <= 12e4) return notes;
+	const cut = notes.slice(0, releaseBodyLimit);
+	return `${cut.slice(0, cut.lastIndexOf("\n"))}\n\n…the notes are too long for a GitHub release${url ? `; see ${url}` : ""}.\n`;
+}
+/** Creates the GitHub release of a tag unless it exists. Needs `GITHUB_TOKEN` and the repository. */
+async function publishGitHubRelease(environment, release) {
+	const token = environment.env.GITHUB_TOKEN ?? environment.env.GH_TOKEN;
+	const repositoryUrl = getRepositoryUrl(environment.cwd, environment.env);
+	const repository = repositoryUrl?.replace(/^https:\/\/[^/]+\//, "");
+	if (!token || !repository) {
+		environment.log("! Skip the GitHub release: set GITHUB_TOKEN and a GitHub repository URL.");
+		return;
+	}
+	const api = `${environment.env.GITHUB_API_URL ?? "https://api.github.com"}/repos/${repository}/releases`;
+	const headers = {
+		authorization: `Bearer ${token}`,
+		accept: "application/vnd.github+json",
+		"content-type": "application/json",
+		"x-github-api-version": "2022-11-28"
+	};
+	const existing = await environment.fetch(`${api}/tags/${encodeURIComponent(release.tag)}`, { headers });
+	if (existing.ok) {
+		environment.log(`✓ GitHub release ${release.tag} exists.`);
+		return (await existing.json()).html_url;
+	}
+	const response = await environment.fetch(api, {
+		method: "POST",
+		headers,
+		body: JSON.stringify({
+			tag_name: release.tag,
+			name: release.tag,
+			body: truncateNotes(release.notes, repositoryUrl ? `${repositoryUrl}/compare` : void 0),
+			prerelease: release.prerelease,
+			make_latest: release.prerelease ? "false" : "true"
+		})
+	});
+	if (!response.ok) throw new Error(`Could not create the GitHub release ${release.tag}: ${response.status} ${await response.text()}`);
+	const url = (await response.json()).html_url;
+	environment.log(`✓ Created the GitHub release ${url ?? release.tag}.`);
+	return url;
+}
+function describePlan(plan) {
+	const range = plan.from ? `${plan.from}..${plan.head.slice(0, 9)}` : `all commits up to ${plan.head.slice(0, 9)}`;
+	return [
+		`Branch: ${plan.branch}${plan.channel ? ` (npm dist-tag ${plan.channel.distTag})` : ""}`,
+		`Mode: ${plan.mode}`,
+		`Range: ${range}`,
+		...plan.commits.map((decision) => `  ${(decision.release || "none").padEnd(5)} ${decision.hash?.slice(0, 9) ?? ""} ${decision.header}`),
+		`Release: ${plan.release || "none"}${plan.version ? ` → ${plan.version}` : ""}`,
+		`Packages: ${plan.packages.map(({ name }) => name).join(", ") || "none"}`
+	].join("\n");
+}
+/** Creates a missing GitHub release when HEAD carries a version tag from an earlier, interrupted run. */
+async function resumeTaggedRelease(environment, options, plan) {
+	const tags = lines(await git(environment, [
+		"tag",
+		"--list",
+		"v*",
+		"--points-at",
+		"HEAD"
+	]));
+	const tag = plan.channel && tags.find((candidate) => {
+		const prerelease = candidate.includes("-");
+		return plan.channel.prerelease ? candidate.includes(`-${plan.channel.prerelease}.`) : !prerelease;
+	});
+	if (!tag || options.dryRun) return false;
+	const previous = await planRelease({
+		...options,
+		ignoreTags: [tag]
+	}, environment);
+	if (!previous.notes || previous.tag !== tag) return false;
+	environment.log(`${tag} points at HEAD; make sure its GitHub release exists.`);
+	await publishGitHubRelease(environment, {
+		tag,
+		notes: previous.notes,
+		prerelease: Boolean(plan.channel.prerelease)
+	});
+	return true;
+}
+/**
+* Releases the checked-out commit:
+*
+* 1. plan the version from the commits since the channel's last tag;
+* 2. write the version and git head into every published package and pack it;
+* 3. publish each package, in dependency order, on the `aronrepo-staging`
+*    dist-tag, skipping versions already published from the same commit;
+* 4. wait until the registry serves every package, then move the channel's
+*    dist-tag to the new version;
+* 5. push the version tag and create the GitHub release.
+*
+* Every step checks what an interrupted run already did, so rerunning the job
+* finishes a release instead of skipping or duplicating it.
+*/
+async function runRelease(options = {}, environmentOptions = {}) {
+	const environment = createEnvironment(environmentOptions);
+	const { cwd, log } = environment;
+	const plan = await planRelease(options, environment);
+	log(describePlan(plan));
+	if (!plan.channel) {
+		log(`Branch ${plan.branch} does not release. Release branches: main, alpha, beta, rc, canary.`);
+		return {
+			status: "skipped",
+			plan
+		};
+	}
+	if (!plan.version || !plan.tag || !plan.notes) {
+		if (await resumeTaggedRelease(environment, options, plan)) return {
+			status: "resumed",
+			plan
+		};
+		log("No release.");
+		return {
+			status: "none",
+			plan
+		};
+	}
+	if (!plan.packages.length) throw new Error("No published package found. Add `\"publishConfig\": { \"access\": \"public\" }` to the packages that ship.");
+	if (options.dryRun) {
+		log(`\nDry run: would publish ${plan.tag} on ${plan.channel.distTag}.\n\n${plan.notes}`);
+		return {
+			status: "dry-run",
+			plan
+		};
+	}
+	if (await git(environment, ["status", "--porcelain"])) throw new Error("The working tree has changes. Release from a clean checkout.");
+	if (await git(environment, [
+		"tag",
+		"--list",
+		plan.tag
+	])) throw new Error(`${plan.tag} exists but is not reachable from ${plan.branch}.`);
+	const directory = fs.mkdtempSync(path.join(os.tmpdir(), "aronrepo-release-"));
+	const manifests = new Map(plan.packages.map(({ dir }) => {
+		const file = path.join(cwd, dir, "package.json");
+		return [file, fs.readFileSync(file, "utf8")];
+	}));
+	try {
+		const packageManager = detectPackageManager(cwd);
+		for (const pkg of plan.packages) pkg.manifest = writeReleaseManifest(cwd, pkg.dir, plan.version, plan.head);
+		const tarballs = /* @__PURE__ */ new Map();
+		for (const [index, pkg] of plan.packages.entries()) {
+			const destination = path.join(directory, String(index));
+			fs.mkdirSync(destination);
+			const [command, args] = packCommand(packageManager, destination);
+			await environment.run(command, args, {
+				cwd: path.join(cwd, pkg.dir),
+				env: environment.env
+			});
+			const tarball = fs.readdirSync(destination).find((file) => file.endsWith(".tgz"));
+			if (!tarball) throw new Error(`Packing ${pkg.name} produced no tarball.`);
+			const file = path.join(destination, tarball);
+			validatePackedManifest(readPackedManifest(file), pkg, plan.version, plan.head);
+			tarballs.set(pkg.name, file);
+			log(`✓ Packed ${pkg.name}@${plan.version}`);
+		}
+		const npmEnvs = /* @__PURE__ */ new Map();
+		const npmEnv = async (pkg) => {
+			if (!npmEnvs.has(pkg.name)) npmEnvs.set(pkg.name, await createNpmEnv(environment, pkg.name, getRegistry(pkg.manifest, environment.env), directory));
+			return npmEnvs.get(pkg.name);
+		};
+		for (const pkg of plan.packages) {
+			const registry = getRegistry(pkg.manifest, environment.env);
+			const published = (await readPackument(environment, registry, pkg.name))?.versions?.[plan.version];
+			if (published) {
+				if (published.gitHead !== plan.head) throw new Error(`${pkg.name}@${plan.version} is already published from ${published.gitHead ?? "another commit"}, not ${plan.head}.`);
+				log(`✓ ${pkg.name}@${plan.version} is already published from this commit.`);
+				continue;
+			}
+			const args = [
+				"publish",
+				tarballs.get(pkg.name),
+				"--tag",
+				stagingDistTag,
+				"--registry",
+				registry
+			];
+			if (pkg.manifest.publishConfig?.access) args.push("--access", String(pkg.manifest.publishConfig.access));
+			if (pkg.manifest.publishConfig?.provenance) args.push("--provenance");
+			await environment.run("npm", args, {
+				cwd,
+				env: await npmEnv(pkg)
+			});
+			log(`✓ Published ${pkg.name}@${plan.version} on ${stagingDistTag}`);
+		}
+		for (const pkg of plan.packages) {
+			const registry = getRegistry(pkg.manifest, environment.env);
+			const published = await waitForVersion(environment, registry, pkg.name, plan.version);
+			if (pkg.manifest.publishConfig?.provenance && !published.dist?.attestations) log(`! ${pkg.name}@${plan.version} has no provenance attestation on ${registry}.`);
+		}
+		for (const pkg of plan.packages) {
+			const registry = getRegistry(pkg.manifest, environment.env);
+			const tags = (await readPackument(environment, registry, pkg.name))?.["dist-tags"] ?? {};
+			const env = await npmEnv(pkg);
+			if (tags[plan.channel.distTag] !== plan.version) await environment.run("npm", [
+				"dist-tag",
+				"add",
+				`${pkg.name}@${plan.version}`,
+				plan.channel.distTag,
+				"--registry",
+				registry
+			], {
+				cwd,
+				env
+			});
+			if (tags["aronrepo-staging"]) await environment.run("npm", [
+				"dist-tag",
+				"rm",
+				pkg.name,
+				stagingDistTag,
+				"--registry",
+				registry
+			], {
+				cwd,
+				env
+			}).catch((error) => log(`! Could not remove the ${stagingDistTag} dist-tag of ${pkg.name}: ${error.message}`));
+			log(`✓ ${pkg.name}@${plan.version} is on ${plan.channel.distTag}`);
+		}
+	} finally {
+		fs.rmSync(directory, {
+			recursive: true,
+			force: true
+		});
+		for (const [file, content] of manifests) fs.writeFileSync(file, content);
+	}
+	await git(environment, [
+		"tag",
+		plan.tag,
+		plan.head
+	]);
+	await git(environment, [
+		"push",
+		"origin",
+		`refs/tags/${plan.tag}`
+	]);
+	log(`✓ Pushed ${plan.tag}`);
+	await publishGitHubRelease(environment, {
+		tag: plan.tag,
+		notes: plan.notes,
+		prerelease: Boolean(plan.channel.prerelease)
+	});
+	return {
+		status: "released",
+		plan
+	};
+}
+// src/commands.ts
+const ignoredMessagePatterns = [
+	/^Merge pull request /,
+	/^Merge (?:branch|remote-tracking branch|tag) /,
+	/^Merge .+ into .+/,
+	/^Merged .+ (?:in|into) .+/,
+	/^Automatic merge/,
+	/^Auto-merged .+ into .+/,
+	/^(?:fixup|squash|amend)! /,
+	/^Initial commit$/
+];
+function isIgnoredMessage(message) {
+	const header = message.trim().split("\n")[0] ?? "";
+	return ignoredMessagePatterns.some((pattern) => pattern.test(header));
+}
+function readEditMessage(file) {
+	return fs.readFileSync(file, "utf8").split("\n").filter((line) => !line.startsWith("#")).join("\n").split(/^-+ >8 -+$/m)[0].trim();
+}
+async function project(options) {
+	return loadProjectPolicy(options.cwd ?? process.cwd(), options.mode ? { mode: options.mode } : {});
+}
+function isError(violation) {
+	return (violation.severity ?? "error") === "error";
+}
+function formatViolation(violation) {
+	return `  ${isError(violation) ? "✗" : "!"} ${violation.message}${violation.suggestion ? `\n    Suggested header: ${violation.suggestion}` : ""}`;
+}
+function formatDecision(decision) {
+	return `${decision.hash ? `${decision.hash.slice(0, 9)} ` : ""}${(decision.release || "none").padEnd(5)}  ${decision.header}\n${decision.reasons.map((reason) => `       ${reason}`).join("\n")}`;
+}
+async function check(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const { policy, isReleasePath } = await project(options);
+	const pathOptions = isReleasePath ? { isReleasePath } : {};
+	let entries;
+	if (options.title !== void 0) {
+		const files = options.files ?? (options.base && options.head ? getDiffFiles(cwd, options.base, options.head) : void 0);
+		entries = [{
+			message: options.title,
+			...files ? { files } : {},
+			label: "PR title"
+		}];
+	} else if (options.edit || options.message !== void 0) entries = [{
+		message: options.edit ? readEditMessage(path.resolve(cwd, options.edit)) : options.message,
+		files: options.files ?? getStagedFiles(cwd),
+		label: "Commit message"
+	}];
+	else if (options.from) entries = getRangeCommits(cwd, options.from, options.to ?? "HEAD").map((commit) => ({
+		...commit,
+		label: commit.hash.slice(0, 9)
+	}));
+	else return {
+		code: 2,
+		output: "Pass --edit <file>, --message <text>, --title <text>, or --from <ref>."
+	};
+	const results = entries.filter(({ message }) => !isIgnoredMessage(message)).map((entry) => ({
+		entry,
+		decision: resolveCommitRelease(parseCommit(entry.message, entry.hash), policy, {
+			...pathOptions,
+			...entry.files ? { files: entry.files } : {}
+		})
+	}));
+	const failures = results.filter(({ decision }) => decision.violations.some(isError));
+	if (options.json) return {
+		code: failures.length ? 1 : 0,
+		output: JSON.stringify({
+			mode: policy.mode,
+			results: results.map(({ entry, decision }) => ({
+				label: entry.label,
+				...decision
+			}))
+		}, null, 2)
+	};
+	if (!failures.length) return {
+		code: 0,
+		output: [...results.map(({ entry, decision }) => [`✓ ${entry.label}: ${decision.release || "none"} ← ${decision.header}`, ...decision.violations.map(formatViolation)].join("\n")), `${results.length} ${results.length === 1 ? "header follows" : "headers follow"} the Aronrepo ${policy.mode} release policy.`].join("\n")
+	};
+	return {
+		code: 1,
+		output: [
+			...failures.map(({ entry, decision }) => `${entry.label}: ${decision.header}\n${decision.violations.map(formatViolation).join("\n")}`),
+			"",
+			"Run `aronrepo policy` to see which types release and which paths ship."
+		].join("\n")
+	};
+}
+async function explain(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const { policy, isReleasePath, releasePaths } = await project(options);
+	let plan;
+	let from;
+	let to = options.to ?? "HEAD";
+	if (options.from === void 0 && options.to === void 0) {
+		plan = await planRelease({
+			fallbackToMain: true,
+			...options.mode ? { mode: options.mode } : {}
+		}, { cwd });
+		from = plan.from;
+		to = "HEAD";
+	} else {
+		from = options.from ?? getLatestTag(cwd, to);
+		plan = resolveRelease(getRangeCommits(cwd, from, to), policy, isReleasePath ? { isReleasePath } : {});
+	}
+	if (options.json) return {
+		code: 0,
+		output: JSON.stringify({
+			mode: policy.mode,
+			...plan.branch ? { branch: plan.branch } : {},
+			...plan.channel ? { channel: plan.channel } : {},
+			from: from ?? null,
+			to,
+			releasePaths: releasePaths ?? null,
+			release: plan.release,
+			version: plan.version ?? null,
+			tag: plan.tag ?? null,
+			commits: plan.commits
+		}, null, 2)
+	};
+	return {
+		code: 0,
+		output: [
+			`Range: ${from ? `${from}..${to}` : `all commits up to ${to}`}`,
+			`Mode: ${policy.mode}`,
+			...plan.channel ? [`Channel: ${plan.channel.branch} (npm dist-tag ${plan.channel.distTag})`] : [],
+			`Release paths: ${releasePaths?.include ? releasePaths.include.join(", ") : "every path"}`,
+			"",
+			...plan.commits.length ? plan.commits.map(formatDecision) : ["No commits."],
+			"",
+			`Next release: ${plan.release || "none"}${plan.version ? ` (${plan.version})` : ""}`
+		].join("\n")
+	};
+}
+async function release(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const result = await runRelease({
+		...options.mode ? { mode: options.mode } : {},
+		...options.branch ? { branch: options.branch } : {},
+		...options.dryRun ? { dryRun: true } : {}
+	}, {
+		cwd,
+		log: options.json ? () => {} : options.log ?? ((message) => console.log(message))
+	});
+	if (!options.json) return {
+		code: 0,
+		output: ""
+	};
+	const { packages, ...plan } = result.plan;
+	return {
+		code: 0,
+		output: JSON.stringify({
+			status: result.status,
+			...plan,
+			packages: packages.map(({ dir, name }) => ({
+				dir,
+				name
+			}))
+		}, null, 2)
+	};
+}
+async function policy(options) {
+	const resolved = await project(options);
+	if (options.markdown) return {
+		code: 0,
+		output: renderAgentsBlock(resolved.policy, {
+			cli: resolved.cli,
+			...resolved.releasePaths ? { releasePaths: resolved.releasePaths } : {}
+		})
+	};
+	const data = {
+		mode: resolved.policy.mode,
+		configFile: resolved.configFile ? path.relative(resolved.cwd, resolved.configFile) : null,
+		releasePaths: resolved.releasePaths ?? null,
+		releaseTable: getReleaseTable(resolved.policy),
+		types: commits.map(({ type, scope, description, group }) => ({
+			type,
+			...scope ? { scope } : {},
+			release: getReleaseType(type, scope, resolved.policy) ?? false,
+			description,
+			...group ? { group } : {}
+		})),
+		legacyTypes: legacyCommits,
+		agent: getAgentCommitPolicy(resolved.policy, { cli: resolved.cli })
+	};
+	if (options.json) return {
+		code: 0,
+		output: JSON.stringify(data, null, 2)
+	};
+	return {
+		code: 0,
+		output: [
+			`Mode: ${data.mode}${data.configFile ? ` (${data.configFile})` : " (default; no aronrepo.config.js)"}`,
+			`Release paths: ${data.releasePaths?.include ? data.releasePaths.include.join(", ") : "every path"}`,
+			...data.releasePaths?.include ? [`Excluded: ${(data.releasePaths.exclude ?? defaultReleasePathExcludes).join(", ")}`] : [],
+			"",
+			`Major: ${data.releaseTable.major.join(", ") || "-"}`,
+			`Minor: ${data.releaseTable.minor.join(", ") || "-"}`,
+			`Patch: ${data.releaseTable.patch.join(", ") || "-"}`,
+			`None:  ${data.releaseTable.none.join(", ") || "-"}`,
+			"",
+			...data.agent.ownerDecisions.map((rule) => `- ${rule}`)
+		].join("\n")
+	};
+}
+function replaceAgentsBlock(content, block) {
+	const start = content.indexOf(agentsBlockStart);
+	const end = content.indexOf(agentsBlockEnd);
+	if (start !== -1 && end > start) return content.slice(0, start) + block + content.slice(end + agentsBlockEnd.length);
+	return `${content.trimEnd()}${content.trim() ? "\n\n" : ""}${block}\n`;
+}
+function readAgentsBlock(content) {
+	const start = content.indexOf(agentsBlockStart);
+	const end = content.indexOf(agentsBlockEnd);
+	return start !== -1 && end > start ? content.slice(start, end + agentsBlockEnd.length) : void 0;
+}
+async function agents(options) {
+	const resolved = await project(options);
+	const file = path.resolve(resolved.cwd, options.file ?? "AGENTS.md");
+	const relative = path.relative(resolved.cwd, file);
+	const block = renderAgentsBlock(resolved.policy, {
+		cli: resolved.cli,
+		...resolved.releasePaths ? { releasePaths: resolved.releasePaths } : {}
+	});
+	const content = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+	if (options.write) {
+		const next = replaceAgentsBlock(content || "# Agent Guide\n", block);
+		if (next === content) return {
+			code: 0,
+			output: `✓ ${relative} is up to date.`
+		};
+		fs.writeFileSync(file, next);
+		return {
+			code: 0,
+			output: `✓ Wrote the Aronrepo commit policy block to ${relative}.`
+		};
+	}
+	const current = readAgentsBlock(content);
+	if (current === block) return {
+		code: 0,
+		output: `✓ ${relative} has the current Aronrepo commit policy block.`
+	};
+	return {
+		code: 1,
+		output: `✗ ${relative} ${current ? "has an outdated" : "is missing the"} Aronrepo commit policy block. Run \`aronrepo agents --write\`.`
+	};
+}
+function findFile(cwd, names) {
+	return names.map((name) => path.join(cwd, name)).find((file) => fs.existsSync(file));
+}
+function readText(file) {
+	return file ? fs.readFileSync(file, "utf8") : "";
+}
+const legacyDependencies = [
+	"semantic-release",
+	"@commitlint/cli",
+	"@aronrepo/commitlint-config",
+	"@aronrepo/conventional-changelog-config",
+	".",
+	"@aronrepo/semantic-release-config",
+	"@aronrepo/semantic-release-pnpm"
+];
+const legacyConfigFiles = [
+	"release.config.js",
+	"release.config.mjs",
+	"release.config.cjs",
+	".releaserc",
+	".releaserc.js",
+	".releaserc.mjs",
+	".releaserc.json",
+	"commitlint.config.js",
+	"commitlint.config.mjs",
+	"commitlint.config.ts",
+	".commitlintrc",
+	".commitlintrc.js",
+	".commitlintrc.mjs",
+	".commitlintrc.json"
+];
+async function doctor(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const checks = [];
+	let resolved;
+	try {
+		resolved = await project(options);
+		checks.push(resolved.configFile ? {
+			status: "pass",
+			message: `Release mode ${resolved.policy.mode} from ${path.relative(cwd, resolved.configFile)}.`
+		} : {
+			status: "warn",
+			message: `No aronrepo.config.js; using the default ${resolved.policy.mode} mode.`,
+			fix: "Ask the repository owner whether releases are explicit (owner-controlled) or auto, then create aronrepo.config.js with `release.mode`."
+		});
+	} catch (error) {
+		checks.push({
+			status: "fail",
+			message: `aronrepo.config.js failed to load: ${error.message}`
+		});
+	}
+	if (resolved) checks.push(resolved.releasePaths?.include ? {
+		status: "pass",
+		message: `Release paths: ${resolved.releasePaths.include.join(", ")}.`
+	} : {
+		status: "warn",
+		message: "No published package found; every path can release a version.",
+		fix: "Set `release.paths.include` in aronrepo.config.js, or add `publishConfig.access: \"public\"` to published packages."
+	});
+	const pkg = JSON.parse(readText(findFile(cwd, ["package.json"])) || "{}");
+	const dependencies = {
+		...pkg.dependencies,
+		...pkg.devDependencies
+	};
+	checks.push(dependencies.aronrepo ? {
+		status: "pass",
+		message: "aronrepo is installed."
+	} : {
+		status: "fail",
+		message: "aronrepo is not a dependency.",
+		fix: "Install it as a dev dependency, for example `bun add -d aronrepo`."
+	});
+	const leftovers = [...legacyDependencies.filter((name) => dependencies[name]), ...legacyConfigFiles.filter((name) => fs.existsSync(path.join(cwd, name)))];
+	checks.push(leftovers.length ? {
+		status: "warn",
+		message: `Leftovers from semantic-release or commitlint: ${leftovers.join(", ")}.`,
+		fix: "Remove them; `aronrepo check` lints commits and `aronrepo release` publishes releases."
+	} : {
+		status: "pass",
+		message: "No semantic-release or commitlint leftovers."
+	});
+	try {
+		const releasePackages = getReleasePackages(cwd);
+		const rootRepository = pkg.repository;
+		const withoutRepository = releasePackages.filter(({ manifest }) => manifest.publishConfig?.provenance && !manifest.repository && !rootRepository);
+		checks.push(!releasePackages.length ? {
+			status: "warn",
+			message: "`aronrepo release` finds no published package.",
+			fix: "Add `\"publishConfig\": { \"access\": \"public\" }` to each package that ships."
+		} : withoutRepository.length ? {
+			status: "warn",
+			message: `npm provenance needs a \`repository\` field: ${withoutRepository.map(({ name }) => name).join(", ")}.`,
+			fix: "Add `repository` to those package.json files."
+		} : {
+			status: "pass",
+			message: `\`aronrepo release\` publishes ${releasePackages.map(({ name }) => name).join(", ")}.`
+		});
+	} catch (error) {
+		checks.push({
+			status: "fail",
+			message: error.message
+		});
+	}
+	const hook = readText(findFile(cwd, [".husky/commit-msg"]));
+	checks.push(hook.includes("aronrepo check") ? {
+		status: "pass",
+		message: ".husky/commit-msg runs aronrepo check."
+	} : {
+		status: "warn",
+		message: "No commit-msg hook runs `aronrepo check`.",
+		fix: "Add .husky/commit-msg with `aronrepo check --edit \"$1\"`."
+	});
+	const agentsResult = await agents({
+		...options,
+		cwd
+	});
+	checks.push(agentsResult.code === 0 ? {
+		status: "pass",
+		message: "AGENTS.md has the current commit policy block."
+	} : {
+		status: "fail",
+		message: agentsResult.output.replace(/^✗ /, ""),
+		fix: "aronrepo agents --write"
+	});
+	const failed = checks.some(({ status }) => status === "fail");
+	if (options.json) return {
+		code: failed ? 1 : 0,
+		output: JSON.stringify({
+			ok: !failed,
+			checks
+		}, null, 2)
+	};
+	const icon = {
+		pass: "✓",
+		warn: "!",
+		fail: "✗"
+	};
+	return {
+		code: failed ? 1 : 0,
+		output: [
+			...checks.map(({ status, message, fix }) => `${icon[status]} ${message}${fix ? `\n    Fix: ${fix}` : ""}`),
+			"",
+			failed ? "Aronrepo setup is incomplete." : "Aronrepo setup is complete."
+		].join("\n")
+	};
+}
+export { getLatestTag as A, resolveReleasePaths as B, configFileNames as C, getCliCommand as D, findConfigFile as E, loadProjectPolicy as F, queryPublicWorkspaceDirs as I, queryWorkspaceDirs as L, getRangeCommits as M, getStagedFiles as N, getCommitFiles as O, loadConfig as P, readWorkspacePackage as R, writeReleaseManifest as S, explainRange as T, readPackedManifest as _, isIgnoredMessage as a, runRelease as b, release as c, getRegistry as d, getReleasePackages as f, publishGitHubRelease as g, planRelease as h, explain as i, getProjectCliCommand as j, getDiffFiles as k, replaceAgentsBlock as l, officialRegistry as m, check as n, policy as o, getRepositoryUrl as p, doctor as r, readAgentsBlock as s, agents as t, exchangeOidcToken as u, releaseBodyLimit as v, detectPackageManager as w, stagingDistTag as x, runCommand as y, readWorkspacePatterns as z };
+
+//# sourceMappingURL=commands-CO26JPbK.js.map