@aklinker1/zero-changelog 0.1.0

package/dist/semver.mjs

@@ -0,0 +1,142 @@
+//#region src/semver.ts
+const STABLE_REGEX = /^(?<major>[1-9]\d*)\.(?<minor>\d+)\.(?<patch>\d+)$/;
+const UNSTABLE_REGEX = /^0\.(?<minor>\d+)\.(?<patch>\d+)$/;
+const PRERELEASE_REGEX = /^(?<major>[1-9]\d*)\.0\.0-(?<prereleaseType>(alpha|beta|rc))\.(?<prerelease>\d+)$/;
+const STABLE_TYPE = Symbol("stable");
+function parseSemver(version) {
+	const stable = version.match(STABLE_REGEX)?.groups;
+	if (stable) return createStableVersion(parseIntOrThrow(stable.major), parseIntOrThrow(stable.minor), parseIntOrThrow(stable.patch));
+	const unstable = version.match(UNSTABLE_REGEX)?.groups;
+	if (unstable) return createUnstableVersion(parseIntOrThrow(unstable.minor), parseIntOrThrow(unstable.patch));
+	const prerelease = version.match(PRERELEASE_REGEX)?.groups;
+	if (prerelease) return createPrereleaseVersion(parseIntOrThrow(prerelease.major), parsePrereleaseTypeOrThrow(prerelease.prereleaseType), parseIntOrThrow(prerelease.prerelease));
+	throw Error(`Unsupported version format: "${version}". See docs: https://github.com/aklinker1/zero-changelog#semver`);
+}
+function createStableVersion(major, minor, patch) {
+	const bump = (by) => {
+		switch (by) {
+			case "major": return `${major + 1}.0.0`;
+			case "minor": return `${major}.${minor + 1}.0`;
+			case "patch": return `${major}.${minor}.${patch + 1}`;
+			default: return validateGreaterVersion(version, by);
+		}
+	};
+	const compare = (other) => {
+		if (isUnstable(other)) return 1;
+		if (isPrerelease(other)) return major >= other.major ? 1 : -1;
+		if (!isStable(other)) throw Error("Unknown version type: " + other.type);
+		if (major > other.major) return 1;
+		if (major < other.major) return -1;
+		if (minor > other.minor) return 1;
+		if (minor < other.minor) return -1;
+		if (patch > other.patch) return 1;
+		if (patch < other.patch) return -1;
+		return 0;
+	};
+	const version = {
+		type: STABLE_TYPE,
+		version: `${major}.${minor}.${patch}`,
+		major,
+		minor,
+		patch,
+		bump,
+		compare
+	};
+	return version;
+}
+function isStable(semver) {
+	return semver.type === STABLE_TYPE;
+}
+const UNSTABLE_TYPE = Symbol("unstable");
+function createUnstableVersion(minor, patch) {
+	const bump = (by) => {
+		switch (by) {
+			case "major": return `0.${minor + 1}.0`;
+			case "minor":
+			case "patch": return `0.${minor}.${patch + 1}`;
+			default: return validateGreaterVersion(version, by);
+		}
+	};
+	const compare = (other) => {
+		if (isStable(other)) return -1;
+		if (isPrerelease(other)) return -1;
+		if (!isUnstable(other)) throw Error("Unknown version type: " + other.type);
+		if (minor > other.minor) return 1;
+		if (minor < other.minor) return -1;
+		if (patch > other.patch) return 1;
+		if (patch < other.patch) return -1;
+		return 0;
+	};
+	const version = {
+		type: UNSTABLE_TYPE,
+		version: `0.${minor}.${patch}`,
+		major: 0,
+		minor,
+		patch,
+		bump,
+		compare
+	};
+	return version;
+}
+function isUnstable(semver) {
+	return semver.type === UNSTABLE_TYPE;
+}
+const PRERELEASE_TYPE = Symbol("prerelease");
+const PRERELEASE_TYPE_ORDER = {
+	alpha: 0,
+	beta: 1,
+	rc: 2
+};
+function createPrereleaseVersion(major, prereleaseType, prerelease) {
+	const bump = (by) => {
+		switch (by) {
+			case "major":
+			case "minor":
+			case "patch": return `${major}.0.0-${prereleaseType}.${prerelease + 1}`;
+			default: return validateGreaterVersion(version, by);
+		}
+	};
+	const compare = (other) => {
+		if (isUnstable(other)) return 1;
+		if (isStable(other)) return other.major >= major ? -1 : 1;
+		if (!isPrerelease(other)) throw Error("Unknown version type: " + other.type);
+		if (major > other.major) return 1;
+		if (major < other.major) return -1;
+		const prereleaseTypeOrder = PRERELEASE_TYPE_ORDER[prereleaseType];
+		const otherPrereleaseTypeOrder = PRERELEASE_TYPE_ORDER[other.prereleaseType];
+		if (prereleaseTypeOrder > otherPrereleaseTypeOrder) return 1;
+		if (prereleaseTypeOrder < otherPrereleaseTypeOrder) return -1;
+		if (prerelease > other.prerelease) return 1;
+		if (prerelease < other.prerelease) return -1;
+		return 0;
+	};
+	const version = {
+		type: PRERELEASE_TYPE,
+		version: `${major}.0.0-${prereleaseType}.${prerelease}`,
+		major,
+		prereleaseType,
+		prerelease,
+		bump,
+		compare
+	};
+	return version;
+}
+function isPrerelease(semver) {
+	return semver.type === PRERELEASE_TYPE;
+}
+function parseIntOrThrow(value) {
+	const i = parseInt(value);
+	if (isNaN(i)) throw Error(`Cannot convert to number: ${value}`);
+	return i;
+}
+function parsePrereleaseTypeOrThrow(value) {
+	if (value !== "alpha" && value !== "beta" && value !== "rc") throw Error(`Invalid prerelease type: ${value}`);
+	return value;
+}
+function validateGreaterVersion(currentSemver, nextVersion) {
+	const nextSemver = parseSemver(nextVersion);
+	if (nextSemver.compare(currentSemver) <= 0) throw Error("New version must be greater than the current version");
+	return nextSemver.version;
+}
+//#endregion
+export { isPrerelease, isStable, isUnstable, parseSemver };

package/dist/serialize-changelog.d.mts

@@ -0,0 +1,6 @@
+import { ChangelogSection } from "./changelog-section.mjs";
+
+//#region src/serialize-changelog.d.ts
+declare function serializeChangelog(sections: ChangelogSection[]): string;
+//#endregion
+export { serializeChangelog };

package/dist/serialize-changelog.mjs

@@ -0,0 +1,28 @@
+import { parseSemver } from "./semver.mjs";
+//#region src/serialize-changelog.ts
+function serializeChangelog(sections) {
+	const parts = ["# Changelog"];
+	const ordered = sections.sort((a, b) => {
+		const aV = a.header.slice(1);
+		const bV = b.header.slice(1);
+		try {
+			const aSemver = parseSemver(aV);
+			try {
+				return parseSemver(bV).compare(aSemver);
+			} catch {
+				return -1;
+			}
+		} catch {
+			try {
+				parseSemver(bV);
+				return 1;
+			} catch {
+				return 0;
+			}
+		}
+	});
+	for (const section of ordered) parts.push(`## ${section.header}`, section.body);
+	return parts.join("\n\n") + "\n";
+}
+//#endregion
+export { serializeChangelog };

package/dist/summarize-unreleased-commits.d.mts

@@ -0,0 +1,50 @@
+import { ConventionalCommit } from "./conventional-commit.mjs";
+import { GitCommit } from "./git-commit.mjs";
+
+//#region src/summarize-unreleased-commits.d.ts
+type SummarizeUnreleasedCommitsOptions = {
+  /**
+   * List of paths to summarize commits for.
+   *
+   * > **IMPORTANT**: You may use glob patterns for ONLY the github action. They are not automatically
+   * > expanded when using the JS API. If you use the JS API and want to use glob patterns, [install a
+   * > glob pattern library](https://www.npmjs.com/search?q=glob) and call it yourself.
+   *
+   * JS Usage:
+   *
+   * ```ts
+   * const summary = await summarizeUnreleasedCommits({
+   *   paths: ["packages/a", "packages/b", "packages/c"],
+   * });
+   * ```
+   *
+   * GitHub Action:
+   *
+   * ```yml
+   * - uses: aklinker1/zero-changelog/actions/summarize-unreleased-commits
+   *   with:
+   *     paths: |-
+   *       packages/*
+   * ```
+   *
+   * @default [process.cwd()]
+   */
+  paths?: string[];
+  /**
+   * Template for the tag prefix. Available variables:
+   *
+   * - `{{dirname}}`: The directory name of the path.
+   * - `{{path}}`: The path relative to the CWD.
+   *
+   * @default "v"
+   */
+  tagPrefixTemplate?: string;
+};
+type PathSummary = {
+  path: string;
+  commits: GitCommit[];
+  conventionalCommits: ConventionalCommit[];
+};
+declare function summarizeUnreleasedCommits(options?: SummarizeUnreleasedCommitsOptions): Promise<PathSummary[]>;
+//#endregion
+export { PathSummary, SummarizeUnreleasedCommitsOptions, summarizeUnreleasedCommits };

package/dist/summarize-unreleased-commits.mjs

@@ -0,0 +1,30 @@
+import { t as findPreviousTag } from "./find-previous-tag-Cj2oZAty.mjs";
+import { t as listCommitsSince } from "./list-commits-since-DycWgHTi.mjs";
+import { parseCommits } from "./parse-commits.mjs";
+import { n as template } from "./utils-BO6byvK5.mjs";
+import { basename, relative, resolve } from "node:path";
+//#region src/summarize-unreleased-commits.ts
+async function summarizeUnreleasedCommits(options) {
+	const { tagPrefixTemplate = "v{{dirname}}" } = options ?? {};
+	const absolutePaths = (options?.paths?.length ? options.paths : [process.cwd()]).map((path) => resolve(path));
+	const summaries = [];
+	for (const path of absolutePaths) {
+		const since = await findPreviousTag(template(tagPrefixTemplate, {
+			dirname: basename(path),
+			path: relative(process.cwd(), path)
+		}));
+		const commits = await listCommitsSince({
+			dirs: [path],
+			since
+		});
+		const conventionalCommits = parseCommits(commits);
+		summaries.push({
+			commits,
+			path,
+			conventionalCommits
+		});
+	}
+	return summaries;
+}
+//#endregion
+export { summarizeUnreleasedCommits };

package/dist/sync-release.d.mts

@@ -0,0 +1,4 @@
+//#region src/sync-release.d.ts
+declare function syncRelease(_options: unknown): Promise<void>;
+//#endregion
+export { syncRelease };

package/dist/sync-release.mjs

@@ -0,0 +1,6 @@
+//#region src/sync-release.ts
+async function syncRelease(_options) {
+	throw Error("TODO");
+}
+//#endregion
+export { syncRelease };

package/dist/sync-releases.d.mts

@@ -0,0 +1,4 @@
+//#region src/sync-releases.d.ts
+declare function syncReleases(_options: unknown): Promise<void>;
+//#endregion
+export { syncReleases };

package/dist/sync-releases.mjs

@@ -0,0 +1,6 @@
+//#region src/sync-releases.ts
+async function syncReleases(_options) {
+	throw Error("TODO");
+}
+//#endregion
+export { syncReleases };

package/dist/update-version-files.d.mts

@@ -0,0 +1,4 @@
+//#region src/update-version-files.d.ts
+declare function updateVersionFiles(path: string, versionFiles: string[], newVersion: string): Promise<void>;
+//#endregion
+export { updateVersionFiles };

package/dist/update-version-files.mjs

@@ -0,0 +1,26 @@
+import { t as getVersionRegexFor } from "./version-regex-C82OGsTC.mjs";
+import { t as replaceRegexGroup } from "./utils-BO6byvK5.mjs";
+import { styleText } from "node:util";
+import { readFile, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+//#region src/update-version-files.ts
+async function updateVersionFiles(path, versionFiles, newVersion) {
+	console.log("Updating version...");
+	for (const versionFile of versionFiles) await updateVersionFile(path, versionFile, newVersion);
+}
+async function updateVersionFile(path, versionFile, newVersion) {
+	const file = join(path, versionFile);
+	const relativePath = relative(process.cwd(), file);
+	try {
+		await writeFile(file, replaceRegexGroup(await readFile(file, "utf8"), getVersionRegexFor(file), "version", newVersion), "utf8");
+		console.log(`  -> ${styleText("cyan", relativePath)} updated`);
+	} catch (err) {
+		if (err.code === "ENOENT") {
+			console.log(`  -> ${styleText("cyan", relativePath)} does not exist, skipping`);
+			return;
+		}
+		throw err;
+	}
+}
+//#endregion
+export { updateVersionFiles };

package/dist/utils-BO6byvK5.mjs

@@ -0,0 +1,22 @@
+//#region src/internal/utils.ts
+/**
+* Replaces a regex group in a string with a replacement value. Only replaces the first match.
+*
+* @param text The string to search in.
+* @param regexp The regex pattern to match. Must include a named group `replace`.
+* @param replacement The value to replace the matched group with.
+* @returns The modified string with the replacement applied.
+*/
+function replaceRegexGroup(text, regexp, group, replacement) {
+	const match = text.match(regexp);
+	if (!match?.groups?.[group]) return text;
+	const fullMatch = match[0];
+	const toReplace = match.groups[group];
+	const newMatch = fullMatch.replace(toReplace, replacement);
+	return text.replace(regexp, newMatch);
+}
+function template(template, vars) {
+	return Object.entries(vars).reduce((acc, [key, value]) => acc.replace(new RegExp(`\\{\\{\\s*?${key}\\s*?\\}\\}`, "g"), String(value)), template);
+}
+//#endregion
+export { template as n, replaceRegexGroup as t };

package/dist/version-regex-C82OGsTC.mjs

@@ -0,0 +1,23 @@
+import { basename } from "node:path";
+//#region src/internal/version-regex.ts
+const PACKAGE_JSON_VERSION_REGEX = /"version":\s*?"(?<version>)"/;
+const PACKAGE_YAML_VERSION_REGEX = /["']?version["']?:\s+?["']?(?<version>)["']?/;
+const CARGO_TOML_VERSION_REGEX = /^version\s*=\s*"(?<version>\w*?)"/;
+function getVersionRegexFor(versionFile) {
+	const filename = basename(versionFile);
+	switch (filename) {
+		case "package.json":
+		case "package.jsonc":
+		case "package.json5":
+		case "deno.json":
+		case "deno.jsonc":
+		case "jsr.json":
+		case "jsr.jsonc": return PACKAGE_JSON_VERSION_REGEX;
+		case "package.yaml":
+		case "package.yml": return PACKAGE_YAML_VERSION_REGEX;
+		case "Cargo.toml": return CARGO_TOML_VERSION_REGEX;
+		default: throw new Error(`Unknown version file: ${filename}`);
+	}
+}
+//#endregion
+export { getVersionRegexFor as t };

package/dist/wait-for-child-process-lyAoE4WE.mjs

@@ -0,0 +1,25 @@
+//#region src/internal/wait-for-child-process.ts
+function waitForChildProcess(child) {
+	return new Promise((resolve, reject) => {
+		let stdout = "";
+		let stderr = "";
+		child.stdout.on("data", (data) => {
+			stdout += data.toString();
+		});
+		child.stderr.on("data", (data) => {
+			stderr += data.toString();
+		});
+		child.on("close", (code) => {
+			if (code === 0) resolve({
+				stdout,
+				stderr
+			});
+			else reject(/* @__PURE__ */ new Error(`Child process exited with code ${code}\n${stderr}`));
+		});
+		child.on("error", (err) => {
+			reject(err);
+		});
+	});
+}
+//#endregion
+export { waitForChildProcess as t };

package/package.json

@@ -0,0 +1,134 @@
+{
+  "name": "@aklinker1/zero-changelog",
+  "version": "0.1.0",
+  "description": "Zero-dependency, conventional commit release and changelog generator with monorepo support",
+  "keywords": [
+    "changelog",
+    "conventional commit",
+    "monorepo",
+    "release notes"
+  ],
+  "license": "MIT",
+  "files": [
+    "dist/"
+  ],
+  "type": "module",
+  "exports": {
+    "./conventional-commit": {
+      "types": "./dist/conventional-commit.d.mts",
+      "default": "./dist/conventional-commit.mjs"
+    },
+    "./get-github-release": {
+      "types": "./dist/get-github-release.d.mts",
+      "default": "./dist/get-github-release.mjs"
+    },
+    "./get-release-notes": {
+      "types": "./dist/get-release-notes.d.mts",
+      "default": "./dist/get-release-notes.mjs"
+    },
+    "./summarize-unreleased-commits": {
+      "types": "./dist/summarize-unreleased-commits.d.mts",
+      "default": "./dist/summarize-unreleased-commits.mjs"
+    },
+    "./list-commits-since": {
+      "types": "./dist/list-commits-since.d.mts",
+      "default": "./dist/list-commits-since.mjs"
+    },
+    "./find-previous-tag": {
+      "types": "./dist/find-previous-tag.d.mts",
+      "default": "./dist/find-previous-tag.mjs"
+    },
+    "./get-github-repo": {
+      "types": "./dist/get-github-repo.d.mts",
+      "default": "./dist/get-github-repo.mjs"
+    },
+    "./detect-version-bump": {
+      "types": "./dist/detect-version-bump.d.mts",
+      "default": "./dist/detect-version-bump.mjs"
+    },
+    "./parse-changelog": {
+      "types": "./dist/parse-changelog.d.mts",
+      "default": "./dist/parse-changelog.mjs"
+    },
+    "./sync-releases": {
+      "types": "./dist/sync-releases.d.mts",
+      "default": "./dist/sync-releases.mjs"
+    },
+    "./parse-commit": {
+      "types": "./dist/parse-commit.d.mts",
+      "default": "./dist/parse-commit.mjs"
+    },
+    "./semver-type-map": {
+      "types": "./dist/semver-type-map.d.mts",
+      "default": "./dist/semver-type-map.mjs"
+    },
+    "./changelog-section": {
+      "types": "./dist/changelog-section.d.mts",
+      "default": "./dist/changelog-section.mjs"
+    },
+    "./release": {
+      "types": "./dist/release.d.mts",
+      "default": "./dist/release.mjs"
+    },
+    "./git-commit": {
+      "types": "./dist/git-commit.d.mts",
+      "default": "./dist/git-commit.mjs"
+    },
+    "./parse-commits": {
+      "types": "./dist/parse-commits.d.mts",
+      "default": "./dist/parse-commits.mjs"
+    },
+    "./update-version-files": {
+      "types": "./dist/update-version-files.d.mts",
+      "default": "./dist/update-version-files.mjs"
+    },
+    "./get-current-version": {
+      "types": "./dist/get-current-version.d.mts",
+      "default": "./dist/get-current-version.mjs"
+    },
+    "./semver-type": {
+      "types": "./dist/semver-type.d.mts",
+      "default": "./dist/semver-type.mjs"
+    },
+    "./semver": {
+      "types": "./dist/semver.d.mts",
+      "default": "./dist/semver.mjs"
+    },
+    "./create-github-release": {
+      "types": "./dist/create-github-release.d.mts",
+      "default": "./dist/create-github-release.mjs"
+    },
+    "./serialize-changelog": {
+      "types": "./dist/serialize-changelog.d.mts",
+      "default": "./dist/serialize-changelog.mjs"
+    },
+    "./sync-release": {
+      "types": "./dist/sync-release.d.mts",
+      "default": "./dist/sync-release.mjs"
+    }
+  },
+  "scripts": {
+    "check": "check",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "build": "bun run --sequential 'build:*'",
+    "build:npm": "tsdown src/*.ts src/semver-types/*.ts --dts.tsgo",
+    "build:actions": "tsdown src/actions/*.ts --minify --d actions/dist",
+    "build:exports": "bun run scripts/gen-export-maps.ts",
+    "prepack": "bun run build:npm"
+  },
+  "devDependencies": {
+    "@actions/core": "^3.0.0",
+    "@actions/glob": "^0.7.0",
+    "@aklinker1/check": "^2.4.0",
+    "@aklinker1/zero-factory": "^1.2.1",
+    "@types/bun": "latest",
+    "@typescript/native-preview": "^7.0.0-dev.20260420.1",
+    "cspell": "^10.0.0",
+    "dedent": "^1.7.2",
+    "oxfmt": "^0.46.0",
+    "oxlint": "^1.60.0",
+    "publint": "^0.3.18",
+    "tsdown": "^0.21.10"
+  }
+}