@qualcomm-ui/changesets-cli 1.2.0 → 2.0.0

package/dist/cli.js

@@ -0,0 +1,1003 @@
+import { program } from "@commander-js/extra-typings";
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+import * as core from "@actions/core";
+import { getPackages, getPackagesSync } from "@manypkg/get-packages";
+import { readFile, readdir, writeFile } from "node:fs/promises";
+import { extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import dayjs from "dayjs";
+import advancedFormat from "dayjs/plugin/advancedFormat.js";
+import { execFileSync, execSync } from "node:child_process";
+import { Octokit } from "@octokit/rest";
+import { tmpdir } from "node:os";
+import readChangeset from "@changesets/read";
+import writeChangeset from "@changesets/write";
+import { existsSync, readFileSync } from "node:fs";
+import { Node, Project, ts } from "ts-morph";
+//#region src/publishable-packages.ts
+var DEFAULT_CONFIG_LOCATION = join(".changeset", "config.json");
+/**
+* Retrieves all packages in the monorepo that should be published.
+* Filters out packages marked as private and ignored packages.
+*
+* @param configPath - Path to the changesets config file, relative to cwd
+* @param cwd - Working directory (defaults to process.cwd())
+* @returns Array of package objects that are eligible for publishing
+*/
+async function getPublishablePackages(configPath, cwd = process.cwd()) {
+	const { packages } = await getPackages(cwd);
+	const changesetConfig = JSON.parse(await readFile(resolve(cwd, configPath ?? DEFAULT_CONFIG_LOCATION), "utf-8"));
+	const ignoredPackages = new Set(changesetConfig.ignored ?? []);
+	return packages.filter((pkg) => {
+		if (ignoredPackages.has(pkg.packageJson.name)) return false;
+		if (!pkg.packageJson.version) return false;
+		return !pkg.packageJson.private;
+	});
+}
+//#endregion
+//#region src/check-versions.ts
+async function getPublishedVersion(packageName) {
+	const response = await fetch(`https://registry.npmjs.org/${packageName}`);
+	if (response.status === 404) return null;
+	if (!response.ok) throw new Error(`Failed to fetch ${packageName}: ${response.status}`);
+	return (await response.json())["dist-tags"]?.latest || null;
+}
+function compareVersions(current, published) {
+	const [cMajor, cMinor, cPatch] = current.split(".").map(Number);
+	const [pMajor, pMinor, pPatch] = published.split(".").map(Number);
+	if (cMajor !== pMajor) return cMajor - pMajor;
+	if (cMinor !== pMinor) return cMinor - pMinor;
+	return cPatch - pPatch;
+}
+async function checkVersions(options) {
+	const packages = await getPublishablePackages(options?.configPath);
+	const newer = (await Promise.all(packages.map(async (pkg) => {
+		const { packageJson } = pkg;
+		const { name, version } = packageJson;
+		const published = await getPublishedVersion(name);
+		if (!published) return {
+			name,
+			unpublished: true,
+			version
+		};
+		const comparison = compareVersions(version, published);
+		return {
+			current: version,
+			isNewer: comparison > 0,
+			isOlder: comparison < 0,
+			isSame: comparison === 0,
+			name,
+			published
+		};
+	}))).filter((r) => "isNewer" in r && r.isNewer === true);
+	if (newer.length > 0) {
+		console.log("The following packages will be published:");
+		newer.forEach((r) => console.log(`  ${r.name}: ${r.published} -> ${r.current}`));
+		core.setOutput("should-publish", true);
+	} else {
+		console.log("No packages need publishing.");
+		core.setOutput("should-publish", false);
+	}
+}
+//#endregion
+//#region src/consolidate-changelogs.ts
+dayjs.extend(advancedFormat);
+var DATE_FORMAT = "MMM Do, YYYY";
+function getChangedChangelogs() {
+	try {
+		return execSync("git diff --name-only HEAD", { encoding: "utf-8" }).trim().split("\n").filter(Boolean).filter((file) => file.endsWith("CHANGELOG.md"));
+	} catch {
+		console.error("Failed to get changed files from git diff");
+		process.exit(1);
+	}
+}
+async function consolidateChangelog(changelogPath) {
+	const lines = (await readFile(changelogPath, "utf-8")).split("\n");
+	const firstReleaseIndex = lines.findIndex((line) => line.startsWith("## "));
+	if (firstReleaseIndex === -1) return;
+	const secondReleaseIndex = lines.findIndex((line, i) => i > firstReleaseIndex && line.startsWith("## "));
+	const endIndex = secondReleaseIndex === -1 ? lines.length : secondReleaseIndex;
+	const before = lines.slice(0, firstReleaseIndex);
+	const releaseLines = lines.slice(firstReleaseIndex, endIndex);
+	const after = lines.slice(endIndex);
+	const sections = /* @__PURE__ */ new Map();
+	let versionLine = "";
+	let dateLine = "";
+	let currentSection = "";
+	for (const line of releaseLines) {
+		if (line.startsWith("## ")) {
+			const dateMatch = line.match(/\((\d{4}\/\d{2}\/\d{2})\)/);
+			if (dateMatch) {
+				versionLine = line.replace(` (${dateMatch[1]})`, "");
+				dateLine = dayjs(dateMatch[1]).format(DATE_FORMAT);
+			} else {
+				versionLine = line;
+				dateLine = dayjs().format(DATE_FORMAT);
+			}
+			continue;
+		}
+		if (line.startsWith("### Patch Changes") || line.startsWith("### Minor Changes") || line.startsWith("### Major Changes")) continue;
+		if (line.startsWith("### ")) {
+			currentSection = line;
+			if (!sections.has(currentSection)) sections.set(currentSection, []);
+			continue;
+		}
+		if (currentSection && line.trim()) sections.get(currentSection)?.push(line.trim());
+	}
+	const output = [];
+	output.push(versionLine);
+	output.push("");
+	output.push(dateLine);
+	output.push("");
+	for (const [section, items] of sections) {
+		if (items.length === 0) continue;
+		output.push(section);
+		output.push("");
+		output.push(...items);
+		output.push("");
+	}
+	await writeFile(changelogPath, [
+		...before,
+		...output,
+		...after
+	].join("\n"));
+}
+async function consolidateChangelogs() {
+	const changedChangelogs = getChangedChangelogs();
+	if (changedChangelogs.length === 0) {
+		console.log("No changelogs changed");
+		return;
+	}
+	console.log(`Consolidating ${changedChangelogs.length} changelog(s)...`);
+	for (const changelogPath of changedChangelogs) {
+		console.log(`  - ${changelogPath}`);
+		await consolidateChangelog(changelogPath);
+	}
+	console.log("Done");
+}
+//#endregion
+//#region src/create-github-releases.ts
+/**
+* Parses a changelog file to extract the latest version entry.
+*
+* @param path - Path to the CHANGELOG.md file
+* @returns Object containing version, date, and body of the latest entry, or null if parsing fails
+*/
+async function parseChangelog(path) {
+	const lines = (await readFile(path, "utf-8")).split("\n");
+	const firstVersionIndex = lines.findIndex((l) => l.startsWith("## "));
+	if (firstVersionIndex === -1) {
+		console.log(`  No version header found`);
+		return null;
+	}
+	const headerLine = lines[firstVersionIndex];
+	const match = headerLine.match(/^## ([\d.]+)/);
+	if (!match) {
+		console.log(`  Invalid version format: ${headerLine}`);
+		return null;
+	}
+	const [, version, date] = match;
+	const endIndex = lines.findIndex((l, i) => i > firstVersionIndex && l.startsWith("## "));
+	return {
+		body: lines.slice(firstVersionIndex + 1, endIndex === -1 ? void 0 : endIndex).join("\n").trim(),
+		date,
+		version
+	};
+}
+function getRepoFromGitRemote() {
+	const remoteUrl = execSync("git remote get-url origin").toString().trim();
+	const match = remoteUrl.match(/github\.com[/:]([\w.-]+)\/([\w.-]+?)(?:\.git)?$/);
+	if (!match) throw new Error(`Could not parse GitHub owner/repo from remote URL: ${remoteUrl}, use --repo to specify explicitly.`);
+	return {
+		owner: match[1],
+		repo: match[2]
+	};
+}
+async function createGitHubReleases(options) {
+	const octokit = new Octokit({ auth: options.token });
+	const repoOpts = options.repo ? {
+		owner: options.repo.split("/")[0],
+		repo: options.repo.split("/")[1]
+	} : getRepoFromGitRemote();
+	const packages = await getPublishablePackages(options.configPath);
+	for (const pkg of packages) {
+		const changelog = await parseChangelog(join(pkg.dir, "CHANGELOG.md")).catch(() => null);
+		if (!changelog) {
+			console.warn("no changelog found, skipping package:", pkg.packageJson.name);
+			continue;
+		}
+		if (changelog.version !== pkg.packageJson.version) {
+			console.log(`Skipping ${pkg.packageJson.name}: changelog ${changelog.version} !== package.json ${pkg.packageJson.version}`);
+			continue;
+		}
+		const tag = `${pkg.packageJson.name}@${changelog.version}`;
+		const release = await octokit.repos.getReleaseByTag({
+			...repoOpts,
+			tag
+		}).catch(() => null);
+		if (release) {
+			console.log(`Release \x1b[93m${release.data.name}\x1b[0m already exists, skipping`);
+			continue;
+		}
+		console.log(`Creating release: \x1b[96m${tag}\x1b[0m`);
+		await octokit.repos.createRelease({
+			...repoOpts,
+			body: changelog.body,
+			name: tag,
+			tag_name: tag
+		});
+	}
+}
+//#endregion
+//#region src/generate-release-notes.ts
+var RELEASE_NOTES_FILENAME = "release-notes.md";
+function extractLatestEntry(content, fallbackName) {
+	const lines = content.split("\n");
+	const packageName = (lines[0]?.match(/^# (.+) Changelog$/))?.[1] ?? fallbackName;
+	const firstVersionIndex = lines.findIndex((l) => l.startsWith("## "));
+	if (firstVersionIndex === -1) return null;
+	const versionMatch = lines[firstVersionIndex].match(/^## ([\d.]+)/);
+	if (!versionMatch) return null;
+	const version = versionMatch[1];
+	const endIndex = lines.findIndex((l, i) => i > firstVersionIndex && l.startsWith("## "));
+	const bodyLines = lines.slice(firstVersionIndex + 1, endIndex === -1 ? void 0 : endIndex);
+	const date = bodyLines.find((l) => /^[A-Z][a-z]{2} \d/.test(l.trim()))?.trim() ?? "";
+	return {
+		date,
+		packageName,
+		sections: bodyLines.filter((l) => l.trim() !== date).join("\n").trim(),
+		version
+	};
+}
+function isDepsOnlyEntry(sections) {
+	const lines = sections.split("\n").filter((l) => l.trim());
+	const hasOnlyChoresHeader = lines.filter((l) => l.startsWith("### ")).every((l) => l === "### Miscellaneous Chores");
+	const bulletLines = lines.filter((l) => l.startsWith("- "));
+	const allDepsBullets = bulletLines.every((l) => l.includes("**deps:** update dependencies"));
+	return hasOnlyChoresHeader && allDepsBullets && bulletLines.length > 0;
+}
+function getReleaseNotesPath() {
+	return join(tmpdir(), RELEASE_NOTES_FILENAME);
+}
+async function generateReleaseNotes() {
+	const changedChangelogs = getChangedChangelogs();
+	if (changedChangelogs.length === 0) {
+		console.log("No changed changelogs, skipping release notes generation");
+		return "";
+	}
+	const entries = [];
+	for (const changelogPath of changedChangelogs) {
+		const entry = extractLatestEntry(await readFile(changelogPath, "utf-8"), changelogPath);
+		if (entry) entries.push(entry);
+	}
+	if (entries.length === 0) {
+		console.log("No parseable changelog entries found");
+		return "";
+	}
+	const substantive = entries.filter((e) => !isDepsOnlyEntry(e.sections));
+	const depsOnly = entries.filter((e) => isDepsOnlyEntry(e.sections));
+	const lines = ["# Release Notes", ""];
+	for (const entry of substantive) lines.push(`## ${entry.packageName} — ${entry.version} (${entry.date})`, "", entry.sections, "");
+	if (depsOnly.length > 0) {
+		lines.push("---", "", "<details>", "<summary>Dependency-only updates</summary>", "");
+		for (const entry of depsOnly) lines.push(`- ${entry.packageName} — ${entry.version}`);
+		lines.push("", "</details>", "");
+	}
+	const markdown = lines.join("\n");
+	const outPath = getReleaseNotesPath();
+	await writeFile(outPath, markdown);
+	console.log(`Release notes written to ${outPath}`);
+	console.log(`  ${substantive.length} package(s) with changes, ${depsOnly.length} dependency-only update(s)`);
+	return outPath;
+}
+//#endregion
+//#region src/utils.ts
+var defaultCommitTypes = [
+	{
+		section: "Features",
+		type: "feat"
+	},
+	{
+		section: "Features",
+		type: "feature"
+	},
+	{
+		section: "Bug Fixes",
+		type: "fix"
+	},
+	{
+		section: "Performance Improvements",
+		type: "perf"
+	},
+	{
+		section: "Reverts",
+		type: "revert"
+	},
+	{
+		section: "Documentation",
+		type: "docs"
+	},
+	{
+		section: "Styles",
+		type: "style"
+	},
+	{
+		section: "Styles",
+		type: "styles"
+	},
+	{
+		section: "Miscellaneous Chores",
+		type: "chore"
+	},
+	{
+		section: "Code Refactoring",
+		type: "refactor"
+	},
+	{
+		section: "Tests",
+		type: "test"
+	},
+	{
+		section: "Build System",
+		type: "build"
+	},
+	{
+		section: "Continuous Integration",
+		type: "ci"
+	}
+];
+/**
+* Normalizes conventional commit format by removing whitespace between type and
+* scope. Transforms "fix (scope): message" to "fix(scope): message"
+* @param commit - The commit message to normalize
+* @returns Normalized commit message
+*/
+function normalizeConventionalCommit(commit) {
+	const normalized = commit.replace(/^(\w+)\s+(\(.*?\))/, "$1$2");
+	if (normalized.startsWith("- ")) return normalized.substring(2);
+	return normalized;
+}
+/**
+* Checks if a commit message follows conventional commit format
+* @param commit - The commit message to check
+* @returns True if the commit follows conventional commit format
+*/
+function isConventionalCommit(commit) {
+	const normalized = normalizeConventionalCommit(commit);
+	return defaultCommitTypes.some((commitType) => normalized.match(new RegExp(`^(?:-\\s)?${commitType.type}\\s*(?:\(.*\))?!?:`)));
+}
+/**
+* Checks if a commit message indicates a breaking change
+* @param commit - The commit message to check
+* @returns True if the commit contains a breaking change indicator
+*/
+function isBreakingChange(commit) {
+	const normalized = normalizeConventionalCommit(commit);
+	return normalized.includes("BREAKING CHANGE:") || defaultCommitTypes.some((commitType) => normalized.match(new RegExp(`^${commitType.type}\\s*(?:\(.*\))?!:`)));
+}
+/**
+* Filters commits to only conventional commits and maps them to changelog format
+* @param commits - Array of commits to translate
+* @returns Array of conventional commit messages with their associated commit hashes
+*/
+function translateCommitsToConventionalCommitMessages(commits) {
+	return commits.filter((commit) => isConventionalCommit(commit.commitMessage)).map((commit) => ({
+		changelogMessage: normalizeConventionalCommit(commit.commitMessage),
+		commitHashes: [commit.commitHash]
+	}));
+}
+/**
+* Gets the list of files changed between two git refs
+* @param opts - Object containing from and to git refs
+* @returns Array of file paths that changed
+*/
+function getFilesChangedSince(opts) {
+	return execSync(`git diff --name-only ${opts.from}~1...${opts.to}`).toString().trim().split("\n");
+}
+/**
+* Gets the absolute path to the git repository root
+* @returns Absolute path to repository root
+*/
+function getRepoRoot() {
+	return execSync("git rev-parse --show-toplevel").toString().trim().replace(/\n|\r/g, "");
+}
+/**
+* Gets the full commit message for a given commit hash
+* @param commitHash - The git commit hash
+* @returns The full commit message
+*/
+function getCommitMessage(commitHash) {
+	return execSync(`git log -1 --pretty=%B ${commitHash}`).toString().trim();
+}
+/**
+* Extracts all conventional commit messages from a multi-line commit message
+* @param commitMessage - The commit message to parse
+* @returns Array of conventional commit messages found
+*/
+function extractConventionalCommits(commitMessage) {
+	const lines = commitMessage.split("\n");
+	const conventionalCommits = [];
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (trimmed && isConventionalCommit(trimmed)) conventionalCommits.push(normalizeConventionalCommit(trimmed));
+	}
+	return conventionalCommits;
+}
+/**
+* Converts conventional commit messages to changesets based on affected packages
+* @param conventionalMessagesToCommits - Array of conventional messages with their commit hashes
+* @param options - Configuration options including ignored files and packages
+* @returns Array of changesets for affected packages
+*/
+function conventionalMessagesWithCommitsToChangesets(conventionalMessagesToCommits, options) {
+	const { ignoredFiles = [], includeCommitLinks, packages } = options;
+	const repoRoot = getRepoRoot();
+	return conventionalMessagesToCommits.flatMap((entry) => {
+		const filesChanged = getFilesChangedSince({
+			from: entry.commitHashes[0],
+			to: entry.commitHashes[entry.commitHashes.length - 1]
+		}).filter((file) => {
+			return ignoredFiles.every((ignoredPattern) => !file.match(ignoredPattern));
+		});
+		const packagesChanged = packages.filter((pkg) => {
+			const pkgPath = pkg.dir.replace(/\\/g, "/").replace(`${repoRoot}/`, "");
+			return filesChanged.some((file) => file.startsWith(`${pkgPath}/`));
+		});
+		if (packagesChanged.length === 0) return [];
+		return entry.commitHashes.flatMap((hash) => {
+			return extractConventionalCommits(getCommitMessage(hash)).map((msg) => ({
+				hash,
+				message: msg
+			}));
+		}).filter((item, index, self) => index === self.findIndex((other) => other.message === item.message)).flatMap(({ hash, message: conventionalCommit }) => {
+			const changeType = isBreakingChange(conventionalCommit) ? "major" : conventionalCommit.startsWith("feat") ? "minor" : "patch";
+			return {
+				packagesChanged,
+				releases: packagesChanged.map((pkg) => ({
+					name: pkg.packageJson.name,
+					type: changeType
+				})),
+				summary: includeCommitLinks ? `${conventionalCommit}\n\ncommit: ${hash.slice(0, 7)}` : conventionalCommit
+			};
+		});
+	}).filter(Boolean);
+}
+/**
+* Fetches the latest changes from a remote branch
+* @param branch - The branch name to fetch
+*/
+function gitFetch(branch) {
+	execSync(`git fetch origin ${branch}`);
+}
+/**
+* Gets all commit hashes since a specific commit
+* @param sha - The commit SHA to compare against
+* @returns Array of commit hashes since the given commit
+*/
+function getCommitsSinceCommit(sha) {
+	return execSync(`git rev-list ${sha}..HEAD`).toString().split("\n").filter(Boolean).reverse();
+}
+/**
+* Gets all commit hashes since a reference branch or tag
+* @param branch - The branch to compare against
+* @returns Array of commit hashes since the reference point
+*/
+function getCommitsSinceBranch(branch) {
+	gitFetch(branch);
+	return execSync(`git rev-list ${`origin/${branch}`}..HEAD`).toString().split("\n").filter(Boolean).reverse();
+}
+/**
+* Compares two changesets for equality
+* @param a - First changeset
+* @param b - Second changeset
+* @returns True if changesets are equal
+*/
+function compareChangeSet(a, b) {
+	return a.summary.replace(/\n$/, "") === b.summary && JSON.stringify(a.releases) === JSON.stringify(b.releases);
+}
+/**
+* Returns changesets in array a that are not in array b
+* @param a - Array of changesets to filter
+* @param b - Array of changesets to compare against
+* @returns Changesets that exist in a but not in b
+*/
+function difference(a, b) {
+	return a.filter((changeA) => !b.some((changeB) => compareChangeSet(changeA, changeB)));
+}
+//#endregion
+//#region src/main.ts
+var CHANGESET_CONFIG_LOCATION$1 = join(".changeset", "config.json");
+function getCommitsWithMessages(commitHashes) {
+	return commitHashes.map((commitHash) => {
+		return {
+			commitHash,
+			commitMessage: execSync(`git log -n 1 --pretty=format:%B ${commitHash}`).toString()
+		};
+	});
+}
+async function conventionalCommitChangeset(options, cwd = process.cwd()) {
+	const configLocation = options.configPath ?? CHANGESET_CONFIG_LOCATION$1;
+	const changesetConfig = JSON.parse(readFileSync(join(cwd, configLocation)).toString());
+	const ignored = changesetConfig.ignore ?? [];
+	const packages = getPackagesSync(cwd).packages.filter((pkg) => Boolean(pkg.packageJson.version) && !ignored.includes(pkg.packageJson.name));
+	const { baseBranch = "main" } = changesetConfig;
+	const { commitSha, includeCommitLinks } = options;
+	const changesets = conventionalMessagesWithCommitsToChangesets(translateCommitsToConventionalCommitMessages(getCommitsWithMessages(commitSha ? getCommitsSinceCommit(commitSha) : getCommitsSinceBranch(baseBranch))), {
+		ignoredFiles: ignored,
+		includeCommitLinks,
+		packages
+	});
+	const currentChangesets = await readChangeset(cwd);
+	const newChangesets = currentChangesets.length === 0 ? changesets : difference(changesets, currentChangesets);
+	await Promise.all(newChangesets.map((changeset) => writeChangeset(changeset, cwd)));
+}
+//#endregion
+//#region src/update-jsdoc-since-tags.ts
+var NEXT_RELEASE = "next-release";
+var NEXT_RELEASE_TAG_PATTERN = /@since\s+next-release\b/;
+var SOURCE_EXTENSIONS = new Set([
+	".cjs",
+	".cts",
+	".js",
+	".jsx",
+	".mjs",
+	".mts",
+	".ts",
+	".tsx"
+]);
+var EXCLUDED_DIRECTORIES = new Set([
+	".turbo",
+	"__tests__",
+	"build",
+	"coverage",
+	"dist",
+	"lib",
+	"node_modules"
+]);
+var TEST_FILE_PATTERN = /\.(spec|test)\.[cm]?[jt]sx?$/;
+function pluralize(count, singular, plural) {
+	return count === 1 ? singular : plural;
+}
+function formatJsDocSinceUpdateStartMessage() {
+	return "Updating JSDoc @since tags...";
+}
+function formatJsDocSincePackageUpdateProgress({ name, version }) {
+	return `Processing package ${name} ${version}...`;
+}
+function normalizeRelativePath(cwd, filePath) {
+	return relative(cwd, filePath).split(sep).join("/");
+}
+function hasNextReleaseSinceTag(content) {
+	const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, ts.LanguageVariant.Standard, content);
+	let token = scanner.scan();
+	while (token !== ts.SyntaxKind.EndOfFileToken) {
+		if (token === ts.SyntaxKind.MultiLineCommentTrivia) {
+			const text = scanner.getTokenText();
+			if (text.startsWith("/**") && NEXT_RELEASE_TAG_PATTERN.test(text)) return true;
+		}
+		token = scanner.scan();
+	}
+	return false;
+}
+function getNodeName(node) {
+	if (Node.isClassDeclaration(node) || Node.isEnumDeclaration(node) || Node.isFunctionDeclaration(node) || Node.isInterfaceDeclaration(node) || Node.isMethodDeclaration(node) || Node.isMethodSignature(node) || Node.isPropertyDeclaration(node) || Node.isPropertySignature(node) || Node.isTypeAliasDeclaration(node)) return node.getName();
+	if (Node.isVariableStatement(node)) return node.getDeclarationList().getDeclarations().map((declaration) => declaration.getName()).join(", ");
+}
+function getQualifiedEntityName(node) {
+	const name = getNodeName(node);
+	if (!name) return "unknown";
+	const parent = node.getParent();
+	const parentName = parent ? getNodeName(parent) : void 0;
+	if (parentName) return `${parentName}.${name}`;
+	return name;
+}
+function getVersionedPackages(packages) {
+	return packages.flatMap((pkg) => {
+		if (!pkg.version) return [];
+		return [{
+			name: pkg.name,
+			root: pkg.root,
+			version: pkg.version
+		}];
+	});
+}
+function isSourceFile(filePath) {
+	return SOURCE_EXTENSIONS.has(extname(filePath)) && !TEST_FILE_PATTERN.test(filePath);
+}
+async function getSourceFiles(dir) {
+	const entries = (await readdir(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name));
+	const files = [];
+	for (const entry of entries) {
+		const entryPath = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (!EXCLUDED_DIRECTORIES.has(entry.name)) files.push(...await getSourceFiles(entryPath));
+			continue;
+		}
+		if (entry.isFile() && isSourceFile(entry.name)) files.push(entryPath);
+	}
+	return files;
+}
+async function updateSourceFile(filePath, version) {
+	const sourceFile = new Project({
+		compilerOptions: {
+			allowJs: true,
+			checkJs: false
+		},
+		manipulationSettings: {
+			insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: false,
+			useTrailingCommas: true
+		},
+		skipAddingFilesFromTsConfig: true
+	}).addSourceFileAtPath(filePath);
+	let tagCount = 0;
+	sourceFile.forEachDescendant((node) => {
+		if (!Node.isJSDocable(node)) return;
+		for (const jsDoc of node.getJsDocs()) for (const tag of jsDoc.getTags()) if (tag.getTagName() === "since" && tag.getCommentText()?.trim() === NEXT_RELEASE) {
+			tag.set({
+				tagName: "since",
+				text: version
+			});
+			tagCount += 1;
+		}
+	});
+	if (tagCount > 0) await sourceFile.save();
+	return tagCount;
+}
+async function findUnresolvedFiles(cwd, sourceFiles) {
+	const unresolvedFiles = [];
+	for (const filePath of sourceFiles) if (hasNextReleaseSinceTag(await readFile(filePath, "utf-8"))) unresolvedFiles.push(normalizeRelativePath(cwd, filePath));
+	return unresolvedFiles;
+}
+function collectSourceFileSinceTagLocations(cwd, sourceFile) {
+	const filePath = normalizeRelativePath(cwd, sourceFile.getFilePath());
+	const locations = [];
+	sourceFile.forEachDescendant((node) => {
+		if (!Node.isJSDocable(node)) return;
+		for (const jsDoc of node.getJsDocs()) for (const tag of jsDoc.getTags()) if (tag.getTagName() === "since" && tag.getCommentText()?.trim() === NEXT_RELEASE) locations.push({
+			entityName: getQualifiedEntityName(node),
+			filePath
+		});
+	});
+	return locations;
+}
+function createProject() {
+	return new Project({
+		compilerOptions: {
+			allowJs: true,
+			checkJs: false
+		},
+		manipulationSettings: {
+			insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: false,
+			useTrailingCommas: true
+		},
+		skipAddingFilesFromTsConfig: true
+	});
+}
+function getFileSinceTagLocations(cwd, filePath) {
+	return collectSourceFileSinceTagLocations(cwd, createProject().addSourceFileAtPath(filePath));
+}
+async function checkJsDocSinceTags({ cwd = process.cwd(), packages }) {
+	const unresolvedTags = [];
+	for (const pkg of packages) {
+		const sourceFiles = await getSourceFiles(pkg.root);
+		for (const filePath of sourceFiles) unresolvedTags.push(...getFileSinceTagLocations(cwd, filePath));
+	}
+	return { unresolvedTags };
+}
+async function updatePackages(cwd, packages, onProgress) {
+	const updatedPackages = [];
+	const unresolvedFiles = [];
+	for (const pkg of packages) {
+		onProgress?.(formatJsDocSincePackageUpdateProgress(pkg));
+		const sourceFiles = await getSourceFiles(pkg.root);
+		let fileCount = 0;
+		let tagCount = 0;
+		for (const filePath of sourceFiles) {
+			const updatedTags = await updateSourceFile(filePath, pkg.version);
+			if (updatedTags > 0) {
+				fileCount += 1;
+				tagCount += updatedTags;
+			}
+		}
+		if (tagCount > 0) updatedPackages.push({
+			fileCount,
+			name: pkg.name,
+			tagCount,
+			version: pkg.version
+		});
+		unresolvedFiles.push(...await findUnresolvedFiles(cwd, sourceFiles));
+	}
+	return {
+		unresolvedFiles,
+		updatedPackages
+	};
+}
+async function updateJsDocSinceTagsForPackages({ cwd = process.cwd(), onProgress, packages }) {
+	return updatePackages(cwd, getVersionedPackages(packages), onProgress);
+}
+function formatJsDocSinceUpdateResult(result) {
+	const lines = [];
+	if (result.updatedPackages.length > 0) {
+		lines.push("Updated JSDoc @since tags:");
+		for (const pkg of result.updatedPackages) lines.push(`  ${pkg.name} ${pkg.version}: ${pkg.tagCount} ${pluralize(pkg.tagCount, "tag", "tags")} in ${pkg.fileCount} ${pluralize(pkg.fileCount, "file", "files")}`);
+	}
+	if (result.unresolvedFiles.length > 0) {
+		if (lines.length > 0) lines.push("");
+		lines.push("Warning: unresolved @since next-release tags remain after JSDoc version update:");
+		lines.push(...result.unresolvedFiles.map((filePath) => `  ${filePath}`));
+		lines.push("");
+		lines.push("These tags were not rewritten automatically. This is non-blocking, but the updater may need to support another JSDoc shape.");
+	}
+	return lines;
+}
+function formatJsDocSinceCheckResult(result) {
+	if (result.unresolvedTags.length === 0) return ["No @since next-release tags found."];
+	return ["Found @since next-release tags:", ...result.unresolvedTags.map(({ entityName, filePath }) => `  ${filePath}: ${entityName}`)];
+}
+//#endregion
+//#region src/version-bump.ts
+var CHANGESET_CONFIG_LOCATION = join(".changeset", "config.json");
+function normalizePath(path) {
+	return resolve(path);
+}
+function isWithinDirectory(parent, child) {
+	const relativePath = relative(parent, child);
+	return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
+}
+function getPackageLabel(directory) {
+	return directory.replaceAll("\\", "/");
+}
+function getSelectedDirectory(cwd, directory) {
+	return resolve(cwd, directory);
+}
+function getSelectedDirectories({ cwd, directories, directory }) {
+	return (directories && directories.length > 0 ? directories : directory ? [directory] : []).map((selectedDirectory) => ({
+		input: selectedDirectory,
+		root: getSelectedDirectory(cwd, selectedDirectory)
+	}));
+}
+function getPackageSourceSnapshot(pkg, versionOverride) {
+	return {
+		...pkg,
+		root: resolve(pkg.root, "src"),
+		version: versionOverride ?? pkg.version
+	};
+}
+function getPackageSourceSnapshots(packages, versionOverride) {
+	return packages.map((pkg) => getPackageSourceSnapshot(pkg, versionOverride));
+}
+function normalizeGitPath(path) {
+	return path.split(sep).join("/");
+}
+function getBaseBranch({ configPath = CHANGESET_CONFIG_LOCATION, cwd }) {
+	return JSON.parse(readFileSync(join(cwd, configPath), "utf-8")).baseBranch ?? "main";
+}
+function getPackageVersionAtRef(pkg, diffRef, cwd) {
+	const packageJsonPath = normalizeGitPath(relative(cwd, join(pkg.root, "package.json")));
+	try {
+		const packageJson = execFileSync("git", ["show", `${diffRef}:${packageJsonPath}`], {
+			cwd,
+			encoding: "utf-8"
+		});
+		return JSON.parse(packageJson).version;
+	} catch {
+		return;
+	}
+}
+function isGitRefResolvable(diffRef, cwd) {
+	try {
+		execFileSync("git", [
+			"rev-parse",
+			"--verify",
+			`${diffRef}^{commit}`
+		], {
+			cwd,
+			stdio: "ignore"
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getPackagesChangedSinceRef({ cwd, diffRef, packages }) {
+	if (!isGitRefResolvable(diffRef, cwd)) throw new Error(`Git ref "${diffRef}" could not be resolved.`);
+	return packages.filter((pkg) => getPackageVersionAtRef(pkg, diffRef, cwd) !== pkg.version);
+}
+function findContainingPackage(directory, packages) {
+	return packages.filter((pkg) => isWithinDirectory(normalizePath(pkg.root), directory)).sort((a, b) => normalizePath(b.root).length - normalizePath(a.root).length).at(0);
+}
+function selectCustomCheckSnapshots(directories, packages) {
+	return directories.map(({ input, root }) => {
+		const containingPackage = findContainingPackage(root, packages);
+		return {
+			name: containingPackage?.name ?? getPackageLabel(input),
+			root,
+			version: containingPackage?.version
+		};
+	});
+}
+function selectCustomUpdateSnapshots(directories, packages, versionOverride) {
+	return directories.map(({ input, root }) => {
+		const containingPackage = findContainingPackage(root, packages);
+		const version = versionOverride ?? containingPackage?.version;
+		if (!version) throw new Error(`Directory "${input}" is not within a package with a version. Pass --version to update arbitrary directories.`);
+		return {
+			name: containingPackage?.name ?? getPackageLabel(input),
+			root,
+			version
+		};
+	});
+}
+function selectDefaultPackageSourceSnapshots({ configPath, cwd = process.cwd(), diffRef, directories, directory, packages, version }) {
+	const selectedDirectories = getSelectedDirectories({
+		cwd,
+		directories,
+		directory
+	});
+	if (selectedDirectories.length === 0) return getPackageSourceSnapshots(getPackagesChangedSinceRef({
+		cwd,
+		diffRef: diffRef ?? getBaseBranch({
+			configPath,
+			cwd
+		}),
+		packages
+	}), version);
+	return selectCustomUpdateSnapshots(selectedDirectories, packages, version);
+}
+function selectCheckPackageSnapshots({ cwd = process.cwd(), directories, directory, packages }) {
+	const selectedDirectories = getSelectedDirectories({
+		cwd,
+		directories,
+		directory
+	});
+	if (selectedDirectories.length === 0) return getPackageSourceSnapshots(packages);
+	return selectCustomCheckSnapshots(selectedDirectories, packages);
+}
+function getPackageSnapshots(cwd = process.cwd()) {
+	return getPackagesSync(cwd).packages.flatMap((pkg) => {
+		const { name, version } = pkg.packageJson;
+		if (!name) return [];
+		if (!existsSync(join(pkg.dir, "src"))) return [];
+		return [{
+			name,
+			root: pkg.dir,
+			version
+		}];
+	});
+}
+function getCheckPackageSnapshots({ cwd = process.cwd(), directories, directory, packages = getPackageSnapshots(cwd) } = {}) {
+	return selectCheckPackageSnapshots({
+		cwd,
+		directories,
+		directory,
+		packages
+	});
+}
+function getUpdatePackageSnapshots({ configPath, cwd = process.cwd(), diffRef, directories, directory, packages = getPackageSnapshots(cwd), version } = {}) {
+	return selectDefaultPackageSourceSnapshots({
+		configPath,
+		cwd,
+		diffRef,
+		directories,
+		directory,
+		packages,
+		version
+	});
+}
+function bumpVersionsAndMaybeUpdateJsDocSinceTags({ exec = (command) => execSync(command, { stdio: "inherit" }), packageManager = "pnpm" } = {}) {
+	exec(`${packageManager} changeset version`);
+}
+//#endregion
+//#region src/cli.ts
+function buildSteps(options) {
+	const pm = options.packageManager ?? "pnpm";
+	return [
+		{
+			description: "Generate changesets from conventional commits",
+			name: "changeset-generate",
+			run: () => conventionalCommitChangeset({
+				commitSha: options.commitSha,
+				configPath: options.config,
+				includeCommitLinks: options.includeCommitLinks
+			})
+		},
+		{
+			description: "Bump versions and generate changelogs",
+			name: "bump",
+			run: () => bumpVersionsAndMaybeUpdateJsDocSinceTags({ packageManager: pm })
+		},
+		{
+			description: "Consolidate changelog formatting",
+			name: "consolidate-changelogs",
+			run: () => consolidateChangelogs()
+		},
+		{
+			description: "Generate combined release notes",
+			name: "generate-release-notes",
+			run: async () => {
+				await generateReleaseNotes();
+			}
+		}
+	];
+}
+async function waitForConfirmation(stepName) {
+	const rl = createInterface({
+		input: stdin,
+		output: stdout
+	});
+	try {
+		return (await rl.question(`\nStep "${stepName}" completed. Continue to next step? [Y/n] `)).trim().toLowerCase() !== "n";
+	} finally {
+		rl.close();
+	}
+}
+async function run(options) {
+	const steps = buildSteps(options);
+	for (let i = 0; i < steps.length; i++) {
+		const step = steps[i];
+		const stepLabel = `[${i + 1}/${steps.length}]`;
+		console.log(`\n${stepLabel} ${step.description}...`);
+		try {
+			await step.run();
+		} catch (e) {
+			console.error(`\nStep "${step.name}" failed. Aborting prep-release.`);
+			console.error(e);
+			process.exit(1);
+		}
+		if (options.inSteps && i < steps.length - 1) {
+			if (!await waitForConfirmation(step.name)) {
+				console.log("Aborted by user.");
+				process.exit(0);
+			}
+		}
+	}
+	console.log("\nAll prep-release steps completed.");
+}
+program.allowUnknownOption(false);
+program.command("prep-release").description("Run all prep-release steps sequentially").option("--in-steps", "Pause after each step and wait for confirmation before continuing", false).option("--commit-sha <sha>", "Diff each package against the target commit instead of the repository's base branch").option("--include-commit-links", "Embed commit hashes in changeset summaries for changelog links", false).option("--package-manager <command>", "Package manager command to use for changeset version", "pnpm").option("--config <path>", "Path to the changesets config file, relative to the project root").action((options) => run(options));
+program.command("changeset-generate").description("Generate changesets from conventional commits").option("--commit-sha <sha>", "Diff each package against the target commit instead of the repository's base branch").option("--include-commit-links", "Embed commit hashes in changeset summaries for changelog links", false).option("--config <path>", "Path to the changesets config file, relative to the project root").action(({ config, ...options }) => conventionalCommitChangeset({
+	...options,
+	configPath: config
+}));
+program.command("consolidate-changelogs").description("Consolidate changelog formatting").action(() => consolidateChangelogs());
+program.command("generate-release-notes").description("Generate combined release notes").action(async () => {
+	await generateReleaseNotes();
+});
+program.command("check-versions").description("Check which packages have newer versions than what is published on npm").option("--config <path>", "Path to the changesets config file, relative to the project root").action((options) => checkVersions({ configPath: options.config }));
+program.command("check-jsdoc-since-tags").argument("[directories...]", "Directories to scan instead of package sources. If this is omitted, the `src` folder will be used by default").description("Check for JSDoc @since next-release tags without modifying files").action(async (directories) => {
+	const result = await checkJsDocSinceTags({ packages: getCheckPackageSnapshots({ directories }) });
+	for (const line of formatJsDocSinceCheckResult(result)) console.log(line);
+});
+program.command("update-jsdoc-since-tags").argument("[directories...]", "Directories to update instead of package sources").option("--version <version>", "Version to use instead of each containing package's current version").option("--diff-ref <git-ref>", "Git ref to compare package versions against (defaults to the changesets base branch)").description("Replace JSDoc @since next-release tags with package or explicit versions").action(async (directories, options) => {
+	console.log(formatJsDocSinceUpdateStartMessage());
+	const lines = formatJsDocSinceUpdateResult(await updateJsDocSinceTagsForPackages({
+		onProgress: console.log,
+		packages: getUpdatePackageSnapshots({
+			diffRef: options.diffRef,
+			directories,
+			version: options.version
+		})
+	}));
+	if (lines.length === 0) {
+		console.log("No JSDoc @since next-release tags updated.");
+		return;
+	}
+	for (const line of lines) console.log(line);
+});
+program.command("create-github-releases").description("Create GitHub releases for published packages from changelogs").option("--token <token>", "GitHub token for authentication (falls back to TOKEN or GITHUB_TOKEN env vars)").option("--repo <owner/repo>", "GitHub repository in owner/repo format (defaults to git remote origin)").option("--config <path>", "Path to the changesets config file, relative to the project root").action((options) => {
+	const token = options.token ?? process.env.TOKEN ?? process.env.GITHUB_TOKEN;
+	if (!token) {
+		console.error("GitHub token is required. Use --token, or set TOKEN or GITHUB_TOKEN env var.");
+		process.exit(1);
+	}
+	return createGitHubReleases({
+		configPath: options.config,
+		repo: options.repo,
+		token
+	});
+});
+program.parse(process.argv);
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.js.map