cngpac 0.0.1

package/dist/src/_virtual/_rolldown/runtime.mjs

@@ -0,0 +1,35 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+export { __commonJSMin, __exportAll, __require, __toESM };

package/dist/src/changelog.d.mts

@@ -0,0 +1,71 @@
+import { BumpType, ChangelogGenerator } from "./types.mjs";
+
+//#region src/changelog.d.ts
+interface ChangelogGeneratorOptions {
+  /** GitHub token for using the GitHub API */
+  githubToken: string;
+  /**
+   * Custom markdown header format.
+   * Supports template variables:
+   * - {packageName}: The package name
+   * - {version}: The new version
+   *
+   * @default "# {packageName}@{version}"
+   *
+   * @example
+   * ```ts
+   * headerFormat: "## Release {packageName} v{version}"
+   * ```
+   */
+  headerFormat?: string;
+  /**
+   * Custom labels for bump types.
+   * Replaces default labels like "Major Changes", "Minor Changes", etc.
+   *
+   * @example
+   * ```ts
+   * bumpLabels: {
+   *   major: "Breaking Changes",
+   *   minor: "Features",
+   *   patch: "Bugfixes"
+   * }
+   * ```
+   */
+  bumpLabels?: Partial<Record<BumpType, string>>;
+  /**
+   * Custom repository URL format.
+   * Supports template variables:
+   * - {owner}: Repository owner
+   * - {name}: Repository name
+   * - {repoUrl}: Full repository URL
+   *
+   * @default "https://github.com/{owner}/{name}"
+   *
+   * @example
+   * ```ts
+   * repositoryUrl: "https://gitlab.com/{owner}/{name}"
+   * ```
+   */
+  repositoryUrl?: string;
+}
+/**
+ * Creates a customizable changelog generator with configurable formatting options.
+ *
+ * @param options Configuration for the changelog generator
+ * @returns A ChangelogGenerator plugin function
+ *
+ * @example
+ * ```ts
+ * const generator = createChangelogGenerator({
+ *   headerFormat: "# Release {packageName} v{version}",
+ *   bumpLabels: {
+ *     major: "Breaking Changes",
+ *     minor: "Features",
+ *     patch: "Bugfixes"
+ *   }
+ * });
+ * ```
+ */
+declare function createChangelogGenerator(options: ChangelogGeneratorOptions): ChangelogGenerator;
+//#endregion
+export { createChangelogGenerator };

package/dist/src/changelog.mjs

@@ -0,0 +1,92 @@
+import { Octokit } from "./node_modules/.pnpm/@octokit_rest@22.0.1/node_modules/@octokit/rest/dist-src/index.mjs";
+//#region src/changelog.ts
+/**
+* Creates a customizable changelog generator with configurable formatting options.
+*
+* @param options Configuration for the changelog generator
+* @returns A ChangelogGenerator plugin function
+*
+* @example
+* ```ts
+* const generator = createChangelogGenerator({
+*   headerFormat: "# Release {packageName} v{version}",
+*   bumpLabels: {
+*     major: "Breaking Changes",
+*     minor: "Features",
+*     patch: "Bugfixes"
+*   }
+* });
+* ```
+*/
+function createChangelogGenerator(options) {
+	const { headerFormat = "# {packageName}@{version}", bumpLabels = {}, repositoryUrl = "https://github.com/{owner}/{name}" } = options;
+	return async (versionBump, changenotes, config) => {
+		const { repository } = config;
+		const octokit = new Octokit({ auth: options.githubToken });
+		const lines = [];
+		const header = headerFormat.replace("{packageName}", versionBump.packageName).replace("{version}", versionBump.newVersion);
+		lines.push(header);
+		lines.push("");
+		const groups = /* @__PURE__ */ new Map();
+		for (const cn of changenotes) {
+			const cnType = cn.meta.bump;
+			if (!cnType) continue;
+			if (!groups.has(cnType)) groups.set(cnType, []);
+			groups.get(cnType)?.push(cn);
+		}
+		const repoUrl = repositoryUrl.replace("{owner}", repository.owner).replace("{name}", repository.name);
+		for (const bump of [
+			"major",
+			"minor",
+			"patch"
+		]) {
+			const changenotes = groups.get(bump);
+			if (!changenotes) continue;
+			const label = getBumpLabel(bump, bumpLabels);
+			lines.push(`## ${label}`);
+			for (const cn of changenotes) {
+				lines.push("");
+				const commit = cn.commit?.hash ? `[${cn.commit.hash.slice(0, 7)}](${repoUrl}/commit/${cn.commit.hash})` : "";
+				let pull = "";
+				if (cn.commit) {
+					const numberMatches = cn.commit.subject.match(/\(#(\d+)\)/);
+					if (numberMatches) {
+						const prNumber = numberMatches.at(-1);
+						pull = ` - [PR#${prNumber}](${repoUrl}/pull/${prNumber})`;
+					}
+				}
+				let thanks = "";
+				if (cn.commit.hash) {
+					const username = (await octokit.rest.repos.getCommit({
+						owner: repository.owner,
+						repo: repository.name,
+						ref: cn.commit.hash
+					})).data.author?.login;
+					if (username) thanks = ` - Thanks to [@${username}](https://github.com/${username}) !`;
+				}
+				if (thanks === "" && cn.authors.length > 0) thanks = ` - Thanks to ${cn.authors.map((ca) => `[${ca.name}](mailto:${ca.email})`).join(", ")} !`;
+				lines.push(`- ${commit}${pull}${thanks}`);
+				lines.push("");
+				lines.push(`  > ${cn.title}`);
+				const trimmedBody = cn.body.trim();
+				if (trimmedBody) {
+					lines.push("");
+					lines.push(`  ${trimmedBody.split("\n").join("\n  ")}`);
+				}
+			}
+			lines.push("");
+		}
+		return lines.join("\n").trimEnd();
+	};
+}
+function getBumpLabel(bump, customLabels = {}) {
+	if (customLabels[bump]) return customLabels[bump];
+	switch (bump) {
+		case "major": return "Major Changes";
+		case "minor": return "Minor Changes";
+		case "patch": return "Patch Changes";
+		default: return "Changes";
+	}
+}
+//#endregion
+export { createChangelogGenerator };

package/dist/src/changenote.d.mts

@@ -0,0 +1,41 @@
+import { Changenote, ChangenoteMetadata, PrepareConfig } from "./types.mjs";
+
+//#region src/changenote.d.ts
+/**
+ * Extract only the YAML frontmatter from a changenote markdown string.
+ *
+ * Unlike {@link parse}, this does not require a `# Heading` title — useful
+ * when you only need to inspect or update frontmatter fields.
+ *
+ * @throws if frontmatter is missing
+ */
+declare function parseFrontmatter(content: string): Record<string, unknown>;
+/**
+ * Update frontmatter fields in an existing changenote markdown string.
+ *
+ * Uses the remark AST to locate and modify the YAML node, then
+ * serializes the full document back to markdown — preserving
+ * body content faithfully.
+ *
+ * @param content  Original markdown string
+ * @param updates  Key-value pairs to merge into frontmatter
+ * @returns        Updated markdown string
+ * @throws         If no frontmatter is found
+ */
+declare function updateFrontmatter(content: string, updates: Record<string, unknown>): string;
+/** Parse a single changenote markdown file */
+declare function parseChangenotefile(filePath: string): Promise<Changenote>;
+/** Parse changenote content from a string */
+declare function parseChangenoteContent(content: string, filePath: string): Changenote;
+/** Read all changenotes from the changenotes directory */
+declare function readChangenotes(changenotesDir: string): Promise<Changenote[]>;
+/** Write a new changenote file */
+declare function writeChangenote(changenotesDir: string, id: string, frontmatter: ChangenoteMetadata, title: string, body: string): Promise<string>;
+/** Write a prepare config to the .changenotes directory */
+declare function writePrepareConfig(changenotesDir: string, config: PrepareConfig): Promise<string>;
+/** Read the prepare config from the .changenotes directory, or null if not present */
+declare function readPrepareConfig(changenotesDir: string): Promise<PrepareConfig | null>;
+/** Remove the prepare config file after it has been consumed */
+declare function consumePrepareConfig(changenotesDir: string): Promise<void>;
+//#endregion
+export { consumePrepareConfig, parseChangenoteContent, parseChangenotefile, parseFrontmatter, readChangenotes, readPrepareConfig, updateFrontmatter, writeChangenote, writePrepareConfig };

package/dist/src/changenote.mjs

@@ -0,0 +1,184 @@
+import { Ze } from "./node_modules/.pnpm/glob@13.0.6/node_modules/glob/dist/esm/index.min.mjs";
+import remarkFrontmatter from "./node_modules/.pnpm/remark-frontmatter@5.0.0/node_modules/remark-frontmatter/lib/index.mjs";
+import remarkParse from "./node_modules/.pnpm/remark-parse@11.0.0/node_modules/remark-parse/lib/index.mjs";
+import remarkStringify from "./node_modules/.pnpm/remark-stringify@11.0.0/node_modules/remark-stringify/lib/index.mjs";
+import { unified } from "./node_modules/.pnpm/unified@11.0.5/node_modules/unified/lib/index.mjs";
+import { require_dist } from "./node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/index.mjs";
+import fs from "node:fs/promises";
+import { basename, join } from "node:path";
+//#region src/changenote.ts
+var import_dist = require_dist();
+const VALID_BUMPS = new Set([
+	"major",
+	"minor",
+	"patch"
+]);
+function isValidBump(value) {
+	return VALID_BUMPS.has(value);
+}
+/**
+* Extract only the YAML frontmatter from a changenote markdown string.
+*
+* Unlike {@link parse}, this does not require a `# Heading` title — useful
+* when you only need to inspect or update frontmatter fields.
+*
+* @throws if frontmatter is missing
+*/
+function parseFrontmatter(content) {
+	const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+	if (!frontmatterMatch) throw new Error("Changenote is missing frontmatter");
+	return (0, import_dist.parse)(frontmatterMatch[1]) ?? {};
+}
+/**
+* Parse changenote markdown content into structured data.
+*
+* Expects a markdown string with YAML frontmatter delimited by `---` and
+* a first-level heading (`# Title`).
+*
+* @throws if frontmatter is missing or there is no `# Heading`
+*/
+function parse(content) {
+	const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+	if (!frontmatterMatch) throw new Error("Changenote is missing frontmatter");
+	const frontmatter = (0, import_dist.parse)(frontmatterMatch[1]) ?? {};
+	const markdownContent = content.slice(frontmatterMatch[0].length).trim();
+	const tree = unified().use(remarkParse).use(remarkFrontmatter).parse(markdownContent);
+	let title;
+	let titleNodeIdx = -1;
+	for (let i = 0; i < tree.children.length; i++) {
+		const node = tree.children[i];
+		if (node.type === "heading") {
+			const heading = node;
+			if (heading.depth === 1) {
+				title = heading.children.filter((c) => c.type === "text").map((c) => c.value).join("");
+				titleNodeIdx = i;
+				break;
+			}
+		}
+	}
+	if (!title) throw new Error("Changenote must have a title (# Heading)");
+	const bodyTree = {
+		type: "root",
+		children: tree.children.filter((_, i) => i !== titleNodeIdx)
+	};
+	const body = unified().use(remarkStringify).stringify(bodyTree).trim();
+	return {
+		frontmatter,
+		title,
+		body
+	};
+}
+/**
+* Serialize a {@link ChangenoteMarkdown} back to a markdown string.
+*/
+function stringifyChangenote(changenote) {
+	const yaml = (0, import_dist.stringify)(changenote.frontmatter).trim();
+	const lines = [];
+	lines.push("---");
+	lines.push(yaml);
+	lines.push("---");
+	lines.push(`# ${changenote.title}`);
+	lines.push("");
+	lines.push(changenote.body.trim());
+	return lines.join("\n");
+}
+/**
+* Update frontmatter fields in an existing changenote markdown string.
+*
+* Uses the remark AST to locate and modify the YAML node, then
+* serializes the full document back to markdown — preserving
+* body content faithfully.
+*
+* @param content  Original markdown string
+* @param updates  Key-value pairs to merge into frontmatter
+* @returns        Updated markdown string
+* @throws         If no frontmatter is found
+*/
+function updateFrontmatter(content, updates) {
+	const processor = unified().use(remarkParse).use(remarkFrontmatter).use(remarkStringify);
+	const ast = processor.parse(content);
+	let yamlNode;
+	for (const node of ast.children) if (node.type === "yaml") {
+		yamlNode = node;
+		break;
+	}
+	if (!yamlNode) throw new Error("Changenote is missing frontmatter");
+	const data = (0, import_dist.parse)(yamlNode.value) ?? {};
+	Object.assign(data, updates);
+	yamlNode.value = (0, import_dist.stringify)(data).trim();
+	return processor.stringify(ast);
+}
+/** Parse a single changenote markdown file */
+async function parseChangenotefile(filePath) {
+	return parseChangenoteContent(await fs.readFile(filePath, "utf-8"), filePath);
+}
+/** Parse changenote content from a string */
+function parseChangenoteContent(content, filePath) {
+	const id = basename(filePath, ".md");
+	let parsed;
+	try {
+		parsed = parse(content);
+	} catch (err) {
+		if ((err instanceof Error ? err.message : String(err)).includes("title")) throw new Error(`Changenote ${filePath} must have a title (# Heading)`);
+		throw new Error(`Changenote ${filePath} is missing frontmatter`);
+	}
+	const { frontmatter, title, body } = parsed;
+	const bump = frontmatter.bump;
+	if (typeof bump !== "string" || !isValidBump(bump)) throw new Error(`Invalid bump type "${bump}" in ${filePath}. Must be major, minor, or patch.`);
+	return {
+		id,
+		meta: {
+			...frontmatter,
+			bump
+		},
+		title,
+		body,
+		filePath
+	};
+}
+/** Read all changenotes from the changenotes directory */
+async function readChangenotes(changenotesDir) {
+	const files = await Ze(join(changenotesDir, "*.md"));
+	const changenotes = [];
+	for (const file of files) changenotes.push(await parseChangenotefile(file));
+	return changenotes;
+}
+/** Write a new changenote file */
+async function writeChangenote(changenotesDir, id, frontmatter, title, body) {
+	await fs.mkdir(changenotesDir, { recursive: true });
+	const content = stringifyChangenote({
+		frontmatter,
+		title,
+		body
+	});
+	const filePath = join(changenotesDir, `${id}.md`);
+	await fs.writeFile(filePath, content, "utf-8");
+	return filePath;
+}
+const PREPARE_FILE = "prepare.json";
+/** Write a prepare config to the .changenotes directory */
+async function writePrepareConfig(changenotesDir, config) {
+	await fs.mkdir(changenotesDir, { recursive: true });
+	const filePath = join(changenotesDir, PREPARE_FILE);
+	await fs.writeFile(filePath, JSON.stringify(config, null, 2), "utf-8");
+	return filePath;
+}
+/** Read the prepare config from the .changenotes directory, or null if not present */
+async function readPrepareConfig(changenotesDir) {
+	const filePath = join(changenotesDir, PREPARE_FILE);
+	try {
+		const content = await fs.readFile(filePath, "utf-8");
+		return JSON.parse(content);
+	} catch {
+		return null;
+	}
+}
+/** Remove the prepare config file after it has been consumed */
+async function consumePrepareConfig(changenotesDir) {
+	const filePath = join(changenotesDir, PREPARE_FILE);
+	try {
+		await fs.unlink(filePath);
+	} catch {}
+}
+//#endregion
+export { consumePrepareConfig, parseChangenoteContent, parseChangenotefile, parseFrontmatter, readChangenotes, readPrepareConfig, updateFrontmatter, writeChangenote, writePrepareConfig };

package/dist/src/cli/commands/change.d.mts

@@ -0,0 +1,4 @@
+//#region src/cli/commands/change.d.ts
+declare function defaultGenerateNoteName(): string;
+//#endregion
+export { defaultGenerateNoteName };

package/dist/src/cli/commands/change.mjs

@@ -0,0 +1,75 @@
+import "../../node_modules/.pnpm/@clack_prompts@1.2.0/node_modules/@clack/prompts/dist/index.mjs";
+import "../../index.mjs";
+import "node:path";
+//#region src/cli/commands/change.ts
+function defaultGenerateNoteName() {
+	const adjectives = [
+		"brave",
+		"calm",
+		"dark",
+		"eager",
+		"fair",
+		"gentle",
+		"happy",
+		"icy",
+		"jolly",
+		"keen",
+		"lively",
+		"merry",
+		"noble",
+		"odd",
+		"proud",
+		"quick",
+		"rare",
+		"shy",
+		"tall",
+		"warm"
+	];
+	const colors = [
+		"amber",
+		"azure",
+		"coral",
+		"crimson",
+		"ember",
+		"fern",
+		"frost",
+		"gold",
+		"jade",
+		"lemon",
+		"lilac",
+		"maple",
+		"ocean",
+		"onyx",
+		"pearl",
+		"rose",
+		"ruby",
+		"sage",
+		"slate",
+		"teal"
+	];
+	const nouns = [
+		"fox",
+		"bear",
+		"deer",
+		"wolf",
+		"hawk",
+		"lynx",
+		"owl",
+		"pike",
+		"crow",
+		"dove",
+		"frog",
+		"goat",
+		"hare",
+		"ibis",
+		"jay",
+		"kite",
+		"lark",
+		"mole",
+		"newt",
+		"orca"
+	];
+	return `${adjectives[Math.floor(Math.random() * adjectives.length)]}-${colors[Math.floor(Math.random() * colors.length)]}-${nouns[Math.floor(Math.random() * nouns.length)]}`;
+}
+//#endregion
+export { defaultGenerateNoteName };

package/dist/src/formatter.d.mts

@@ -0,0 +1,31 @@
+import { CngpacConfig, FormatterPlugin } from "./types.mjs";
+
+//#region src/formatter.d.ts
+interface FormatterOptions {
+  /** File extensions to handle (without leading dot, e.g. ["json", "md"]) */
+  extensions: string[];
+  /** The command to run (file paths are appended, e.g. "biome format --write") */
+  command: string;
+}
+/**
+ * Creates a formatter plugin that spawns an external command.
+ *
+ * Augments `PATH` with `node_modules/.bin` so the binary resolves
+ * regardless of which package manager installed it.
+ *
+ * @example
+ * ```ts
+ * createFormatter({ extensions: ["json", "ts"], command: "biome format --write" })
+ * createFormatter({ extensions: ["md", "yml"], command: "oxfmt" })
+ * ```
+ */
+declare function createFormatter(options: FormatterOptions): FormatterPlugin;
+/**
+ * Dispatch dirty files to matching formatters by extension.
+ *
+ * Filters out deleted files and routes each surviving file to
+ * every formatter whose `extensions` list includes that file's extension.
+ */
+declare function formatFiles(filePaths: string[], config: CngpacConfig, rootDir: string): Promise<void>;
+//#endregion
+export { FormatterOptions, createFormatter, formatFiles };

package/dist/src/formatter.mjs

@@ -0,0 +1,50 @@
+import { delimiter, extname, join } from "node:path";
+import { existsSync } from "node:fs";
+import { execSync } from "node:child_process";
+//#region src/formatter.ts
+/**
+* Creates a formatter plugin that spawns an external command.
+*
+* Augments `PATH` with `node_modules/.bin` so the binary resolves
+* regardless of which package manager installed it.
+*
+* @example
+* ```ts
+* createFormatter({ extensions: ["json", "ts"], command: "biome format --write" })
+* createFormatter({ extensions: ["md", "yml"], command: "oxfmt" })
+* ```
+*/
+function createFormatter(options) {
+	return {
+		extensions: options.extensions,
+		format: (filePaths, rootDir) => {
+			if (filePaths.length === 0) return;
+			const binDir = join(rootDir, "node_modules", ".bin");
+			execSync(`${options.command} ${filePaths.join(" ")}`, {
+				stdio: "inherit",
+				env: {
+					...process.env,
+					PATH: `${binDir}${delimiter}${process.env.PATH}`
+				}
+			});
+		}
+	};
+}
+/**
+* Dispatch dirty files to matching formatters by extension.
+*
+* Filters out deleted files and routes each surviving file to
+* every formatter whose `extensions` list includes that file's extension.
+*/
+async function formatFiles(filePaths, config, rootDir) {
+	if (!config.formatters?.length || filePaths.length === 0) return;
+	const existing = filePaths.filter((p) => existsSync(p));
+	if (existing.length === 0) return;
+	for (const formatter of config.formatters) {
+		const extSet = new Set(formatter.extensions.map((e) => `.${e}`));
+		const matched = existing.filter((f) => extSet.has(extname(f)));
+		if (matched.length > 0) await formatter.format(matched, rootDir);
+	}
+}
+//#endregion
+export { createFormatter, formatFiles };

package/dist/src/git.d.mts

@@ -0,0 +1,20 @@
+import { ChangenoteCommit, CommitAuthor } from "./types.mjs";
+
+//#region src/git.d.ts
+/** Create a git operations instance for a repository */
+declare function createGitOps(repoDir?: string): {
+  currentBranch(): Promise<string>;
+  getFileAuthors(file: string): Promise<CommitAuthor[]>;
+  getFileAddCommit(filePath: string): Promise<ChangenoteCommit>;
+  getStagedFiles(pattern?: RegExp): Promise<string[]>;
+  getUnstagedFiles(pattern?: RegExp): Promise<string[]>;
+  add(file: string[]): Promise<void>;
+  commit(message: string): Promise<void>;
+  tag(name: string, message?: string): Promise<void>;
+  push(branch?: string): Promise<void>;
+  pushSetUpstream(branch: string): Promise<void>;
+  pushTags(branch?: string): Promise<void>;
+  ensureGitIdentity(): Promise<void>;
+};
+//#endregion
+export { createGitOps };