@williamthorsen/release-kit 4.5.0 → 4.6.0

package/dist/esm/injectSection.js

@@ -0,0 +1,32 @@
+function openMarker(key) {
+  return `<!-- section:${key} -->`;
+}
+function closeMarker(key) {
+  return `<!-- /section:${key} -->`;
+}
+function injectSection(content, key, injection) {
+  const open = openMarker(key);
+  const close = closeMarker(key);
+  const openIndex = content.indexOf(open);
+  const closeIndex = content.indexOf(close);
+  if (openIndex !== -1 && closeIndex !== -1 && closeIndex > openIndex) {
+    const before = content.slice(0, openIndex + open.length);
+    const after = content.slice(closeIndex);
+    return `${before}
+${injection}
+${after}`;
+  }
+  const section = `${open}
+${injection}
+${close}`;
+  if (content.length === 0) {
+    return `${section}
+`;
+  }
+  return `${section}
+
+${content}`;
+}
+export {
+  injectSection
+};

package/dist/esm/loadConfig.js

@@ -1,7 +1,12 @@
 import { existsSync } from "node:fs";
 import path from "node:path";
 import { component } from "./component.js";
-import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
+import {
+  DEFAULT_CHANGELOG_JSON_CONFIG,
+  DEFAULT_RELEASE_NOTES_CONFIG,
+  DEFAULT_VERSION_PATTERNS,
+  DEFAULT_WORK_TYPES
+} from "./defaults.js";
 import { isRecord } from "./typeGuards.js";
 const CONFIG_FILE_PATH = ".config/release-kit.config.ts";
 async function loadConfig() {
@@ -34,10 +39,14 @@ function mergeMonorepoConfig(discoveredPaths, userConfig) {
   }
   const workTypes = userConfig?.workTypes === void 0 ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userConfig.workTypes };
   const versionPatterns = userConfig?.versionPatterns === void 0 ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
+  const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
+  const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
   const result = {
     components,
     workTypes,
-    versionPatterns
+    versionPatterns,
+    changelogJson,
+    releaseNotes
   };
   const formatCommand = userConfig?.formatCommand;
   if (formatCommand !== void 0) {
@@ -56,12 +65,16 @@ function mergeMonorepoConfig(discoveredPaths, userConfig) {
 function mergeSinglePackageConfig(userConfig) {
   const workTypes = userConfig?.workTypes === void 0 ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userConfig.workTypes };
   const versionPatterns = userConfig?.versionPatterns === void 0 ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
+  const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
+  const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
   const result = {
     tagPrefix: "v",
     packageFiles: ["package.json"],
     changelogPaths: ["."],
     workTypes,
-    versionPatterns
+    versionPatterns,
+    changelogJson,
+    releaseNotes
   };
   const formatCommand = userConfig?.formatCommand;
   if (formatCommand !== void 0) {
@@ -77,6 +90,25 @@ function mergeSinglePackageConfig(userConfig) {
   }
   return result;
 }
+function mergeChangelogJsonConfig(partial) {
+  if (partial === void 0) {
+    return { ...DEFAULT_CHANGELOG_JSON_CONFIG };
+  }
+  return {
+    enabled: partial.enabled ?? DEFAULT_CHANGELOG_JSON_CONFIG.enabled,
+    outputPath: partial.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath,
+    devOnlySections: partial.devOnlySections ?? [...DEFAULT_CHANGELOG_JSON_CONFIG.devOnlySections]
+  };
+}
+function mergeReleaseNotesConfig(partial) {
+  if (partial === void 0) {
+    return { ...DEFAULT_RELEASE_NOTES_CONFIG };
+  }
+  return {
+    shouldInjectIntoReadme: partial.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme,
+    shouldCreateGithubRelease: partial.shouldCreateGithubRelease ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldCreateGithubRelease
+  };
+}
 export {
   CONFIG_FILE_PATH,
   loadConfig,

package/dist/esm/parseCommitMessage.js

@@ -1,4 +1,4 @@
-const COMMIT_PREPROCESSOR_PATTERNS = [/^#\d+\s+/, /^[A-Z]+-\d+\s+/];
+const COMMIT_PREPROCESSOR_PATTERNS = [/^#\d+([.-]\d+)?\s+/, /^[A-Z]+-\d+\s+/];
 function parseCommitMessage(message, hash, workTypes, scopeAliases) {
   const stripped = stripTicketPrefix(message);
   const match = stripped.match(/^(?:([^|]+)\|)?(\w+)(?:\(([^)]+)\))?(!)?:\s*(.*)$/);

package/dist/esm/prepareCommand.d.ts

@@ -5,6 +5,7 @@ export declare const RELEASE_SUMMARY_FILE = "tmp/.release-summary";
 export declare function parseArgs(argv: string[]): {
     dryRun: boolean;
     force: boolean;
+    noGitChecks: boolean;
     bumpOverride: ReleaseType | undefined;
     only: string[] | undefined;
 };

package/dist/esm/prepareCommand.js

@@ -3,6 +3,7 @@ import {
   translateParseError,
   writeFileWithCheck
 } from "@williamthorsen/node-monorepo-core";
+import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
 import { buildReleaseSummary } from "./buildReleaseSummary.js";
 import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { dim } from "./format.js";
@@ -25,6 +26,7 @@ Options:
   --dry-run             Run without modifying any files
   --bump=major|minor|patch  Override the bump type for all components
   --force               Bypass the "no commits since last tag" check (monorepo only, requires --bump)
+  --no-git-checks, -n   Skip the clean-working-tree check
   --only=name1,name2    Only process the named components (comma-separated, monorepo only)
   --help                Show this help message
 `);
@@ -32,6 +34,11 @@ Options:
 const prepareFlagSchema = {
   dryRun: { long: "--dry-run", type: "boolean" },
   force: { long: "--force", type: "boolean" },
+  noGitChecks: {
+    long: "--no-git-checks",
+    type: "boolean",
+    short: "-n"
+  },
   bump: { long: "--bump", type: "string" },
   only: { long: "--only", type: "string" },
   help: { long: "--help", type: "boolean", short: "-h" }
@@ -62,21 +69,31 @@ function parseArgs(argv) {
   if (flags.force && bumpOverride === void 0) {
     throw new Error("--force requires --bump to specify the version bump type");
   }
-  return { dryRun: flags.dryRun, force: flags.force, bumpOverride, only };
+  return {
+    dryRun: flags.dryRun,
+    force: flags.force,
+    noGitChecks: flags.noGitChecks,
+    bumpOverride,
+    only
+  };
 }
 function writeReleaseTags(tags, dryRun) {
   if (tags.length === 0) {
     return void 0;
   }
-  return writeFileWithCheck(RELEASE_TAGS_FILE, tags.join("\n"), { dryRun, overwrite: true });
+  return writeFileWithCheck(RELEASE_TAGS_FILE, tags.join("\n"), {
+    dryRun,
+    overwrite: true
+  });
 }
 async function prepareCommand(argv) {
   let dryRun;
   let force;
+  let noGitChecks;
   let bumpOverride;
   let only;
   try {
-    ({ dryRun, force, bumpOverride, only } = parseArgs(argv));
+    ({ dryRun, force, noGitChecks, bumpOverride, only } = parseArgs(argv));
   } catch (error) {
     console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
@@ -89,25 +106,15 @@ async function prepareCommand(argv) {
   if (dryRun) {
     console.info("\n\u{1F50D} DRY RUN \u2014 no files will be modified\n");
   }
-  let rawConfig;
-  try {
-    rawConfig = await loadConfig();
-  } catch (error) {
-    console.error(`Error loading config: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
-  }
-  let userConfig;
-  if (rawConfig !== void 0) {
-    const { config, errors } = validateConfig(rawConfig);
-    if (errors.length > 0) {
-      console.error("Invalid config:");
-      for (const err of errors) {
-        console.error(`  \u274C ${err}`);
-      }
+  if (!dryRun && !noGitChecks) {
+    try {
+      assertCleanWorkingTree();
+    } catch (error) {
+      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
       process.exit(1);
     }
-    userConfig = config;
   }
+  const userConfig = await loadAndValidateConfig();
   let discoveredPaths;
   try {
     discoveredPaths = await discoverWorkspaces();
@@ -137,6 +144,30 @@ async function prepareCommand(argv) {
     runAndReport(() => releasePrepareMono(config, options), dryRun);
   }
 }
+async function loadAndValidateConfig() {
+  let rawConfig;
+  try {
+    rawConfig = await loadConfig();
+  } catch (error) {
+    console.error(`Error loading config: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+  if (rawConfig === void 0) {
+    return void 0;
+  }
+  const { config, errors, warnings } = validateConfig(rawConfig);
+  if (errors.length > 0) {
+    console.error("Invalid config:");
+    for (const err of errors) {
+      console.error(`  \u274C ${err}`);
+    }
+    process.exit(1);
+  }
+  for (const warning of warnings) {
+    console.warn(`  \u26A0\uFE0F  ${warning}`);
+  }
+  return config;
+}
 function runAndReport(execute, dryRun) {
   let result;
   try {
@@ -162,7 +193,10 @@ function runAndReport(execute, dryRun) {
   }
   const summary = buildReleaseSummary(result);
   if (summary.length > 0) {
-    const summaryResult = writeFileWithCheck(RELEASE_SUMMARY_FILE, summary, { dryRun, overwrite: true });
+    const summaryResult = writeFileWithCheck(RELEASE_SUMMARY_FILE, summary, {
+      dryRun,
+      overwrite: true
+    });
     if (summaryResult.outcome === "failed") {
       console.error(`Error writing release summary: ${summaryResult.error ?? "unknown error"}`);
       process.exit(1);

package/dist/esm/publish.d.ts

@@ -5,4 +5,4 @@ export interface PublishOptions {
     noGitChecks: boolean;
     provenance: boolean;
 }
-export declare function publish(resolvedTags: ResolvedTag[], packageManager: PackageManager, options: PublishOptions): void;
+export declare function publishPackage(resolvedTag: ResolvedTag, packageManager: PackageManager, options: PublishOptions): void;

package/dist/esm/publish.js

@@ -1,32 +1,13 @@
 import { execFileSync } from "node:child_process";
-function publish(resolvedTags, packageManager, options) {
+function publishPackage(resolvedTag, packageManager, options) {
   const { dryRun, noGitChecks, provenance } = options;
-  if (resolvedTags.length === 0) {
-    return;
-  }
-  console.info(dryRun ? "[dry-run] Would publish:" : "Publishing:");
-  for (const { tag, workspacePath } of resolvedTags) {
-    console.info(`  ${tag} (${workspacePath})`);
-  }
-  const published = [];
   const executable = resolveExecutable(packageManager);
   const args = buildPublishArgs(packageManager, { dryRun, noGitChecks, provenance });
-  for (const { tag, workspacePath } of resolvedTags) {
-    try {
-      console.info(`
-${dryRun ? "[dry-run] " : ""}Running: ${executable} ${args.join(" ")} (cwd: ${workspacePath})`);
-      execFileSync(executable, args, { cwd: workspacePath, stdio: "inherit" });
-      published.push(tag);
-    } catch (error) {
-      if (published.length > 0) {
-        console.warn("Packages published before failure:");
-        for (const t of published) {
-          console.warn(`  ${t}`);
-        }
-      }
-      throw error;
-    }
-  }
+  console.info(
+    `
+${dryRun ? "[dry-run] " : ""}Running: ${executable} ${args.join(" ")} (cwd: ${resolvedTag.workspacePath})`
+  );
+  execFileSync(executable, args, { cwd: resolvedTag.workspacePath, stdio: "inherit" });
 }
 function resolveExecutable(packageManager) {
   if (packageManager === "yarn-berry") {
@@ -48,5 +29,5 @@ function buildPublishArgs(packageManager, options) {
   return args;
 }
 export {
-  publish
+  publishPackage
 };

package/dist/esm/publishCommand.js

@@ -1,9 +1,12 @@
-import { basename } from "node:path";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { createGithubReleases } from "./createGithubRelease.js";
 import { detectPackageManager } from "./detectPackageManager.js";
-import { discoverWorkspaces } from "./discoverWorkspaces.js";
-import { publish } from "./publish.js";
-import { resolveReleaseTags } from "./resolveReleaseTags.js";
+import { injectReleaseNotesIntoReadme, resolveReadmePath } from "./injectReleaseNotesIntoReadme.js";
+import { publishPackage } from "./publish.js";
+import { resolveCommandTags } from "./resolveCommandTags.js";
+import { resolveReleaseNotesConfig } from "./resolveReleaseNotesConfig.js";
 const publishFlagSchema = {
   dryRun: { long: "--dry-run", type: "boolean" },
   noGitChecks: { long: "--no-git-checks", type: "boolean" },
@@ -20,38 +23,55 @@ async function publishCommand(argv) {
   }
   const { dryRun, noGitChecks, provenance } = parsed.flags;
   const only = parsed.flags.only?.split(",");
-  let discoveredPaths;
-  try {
-    discoveredPaths = await discoverWorkspaces();
-  } catch (error) {
-    console.error(`Error discovering workspaces: ${error instanceof Error ? error.message : String(error)}`);
-    process.exit(1);
-  }
-  if (only !== void 0 && discoveredPaths === void 0) {
-    console.error("Error: --only is only supported for monorepo configurations");
-    process.exit(1);
-  }
-  const workspaceMap = discoveredPaths === void 0 ? void 0 : new Map(discoveredPaths.map((p) => [basename(p), p]));
-  let resolvedTags = resolveReleaseTags(workspaceMap);
+  const resolvedTags = await resolveCommandTags(only);
   if (resolvedTags.length === 0) {
-    console.error("Error: No release tags found on HEAD. Create tags with `release-kit tag` first.");
-    process.exit(1);
+    return;
+  }
+  const packageManager = detectPackageManager();
+  const { releaseNotes, changelogJsonOutputPath } = await resolveReleaseNotesConfig();
+  const shouldInject = releaseNotes.shouldInjectIntoReadme;
+  console.info(dryRun ? "[dry-run] Would publish:" : "Publishing:");
+  for (const { tag, workspacePath } of resolvedTags) {
+    console.info(`  ${tag} (${workspacePath})`);
   }
-  if (only !== void 0) {
-    const availableNames = resolvedTags.map((t) => t.dir);
-    for (const name of only) {
-      if (!availableNames.includes(name)) {
-        console.error(`Error: Unknown package "${name}" in --only. Available: ${availableNames.join(", ")}`);
-        process.exit(1);
+  const published = [];
+  try {
+    for (const resolvedTag of resolvedTags) {
+      let readmePath;
+      let originalReadme;
+      if (shouldInject) {
+        readmePath = resolveReadmePath(resolvedTag.workspacePath);
+        if (readmePath !== void 0) {
+          originalReadme = injectReleaseNotesIntoReadme(
+            readmePath,
+            join(resolvedTag.workspacePath, changelogJsonOutputPath),
+            resolvedTag.tag
+          );
+        }
+      }
+      try {
+        publishPackage(resolvedTag, packageManager, { dryRun, noGitChecks, provenance });
+        published.push(resolvedTag.tag);
+      } finally {
+        if (readmePath !== void 0 && originalReadme !== void 0) {
+          writeFileSync(readmePath, originalReadme, "utf8");
+        }
+      }
+    }
+  } catch (error) {
+    if (published.length > 0) {
+      console.warn("Packages published before failure:");
+      for (const t of published) {
+        console.warn(`  ${t}`);
       }
     }
-    resolvedTags = resolvedTags.filter((t) => only.includes(t.dir));
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
   }
-  const packageManager = detectPackageManager();
   try {
-    publish(resolvedTags, packageManager, { dryRun, noGitChecks, provenance });
+    createGithubReleases(resolvedTags, releaseNotes, changelogJsonOutputPath, dryRun);
   } catch (error) {
-    console.error(error instanceof Error ? error.message : String(error));
+    console.error(`Error creating GitHub Releases: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
   }
 }

package/dist/esm/releasePrepare.js

@@ -2,6 +2,7 @@ import { execSync } from "node:child_process";
 import { bumpAllVersions } from "./bumpAllVersions.js";
 import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { determineBumpFromCommits } from "./determineBumpFromCommits.js";
+import { generateChangelogJson } from "./generateChangelogJson.js";
 import { generateChangelogs } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { hasPrettierConfig } from "./hasPrettierConfig.js";
@@ -42,10 +43,20 @@ function releasePrepare(config, options) {
   const bump = bumpAllVersions(config.packageFiles, releaseType, dryRun);
   const newTag = `${config.tagPrefix}${bump.newVersion}`;
   const changelogFiles = generateChangelogs(config, newTag, dryRun);
+  const changelogJsonFiles = [];
+  if (config.changelogJson.enabled) {
+    for (const changelogPath of config.changelogPaths) {
+      changelogJsonFiles.push(...generateChangelogJson(config, changelogPath, newTag, dryRun));
+    }
+  }
   const formatCommandStr = config.formatCommand ?? (hasPrettierConfig() ? "npx prettier --write" : void 0);
   let formatCommand;
   if (formatCommandStr !== void 0) {
-    const modifiedFiles = [...config.packageFiles, ...config.changelogPaths.map((p) => `${p}/CHANGELOG.md`)];
+    const modifiedFiles = [
+      ...config.packageFiles,
+      ...config.changelogPaths.map((p) => `${p}/CHANGELOG.md`),
+      ...changelogJsonFiles
+    ];
     const fullCommand = `${formatCommandStr} ${modifiedFiles.join(" ")}`;
     if (dryRun) {
       formatCommand = { command: fullCommand, executed: false, files: modifiedFiles };

package/dist/esm/releasePrepareMono.js

@@ -4,6 +4,7 @@ import { buildDependencyGraph } from "./buildDependencyGraph.js";
 import { bumpAllVersions } from "./bumpAllVersions.js";
 import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { determineBumpFromCommits } from "./determineBumpFromCommits.js";
+import { generateChangelogJson, generateSyntheticChangelogJson } from "./generateChangelogJson.js";
 import { buildTagPattern, generateChangelog } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { hasPrettierConfig } from "./hasPrettierConfig.js";
@@ -169,6 +170,19 @@ function executeReleaseSet(sortedDirs, fullReleaseSet, config, directResults, pr
           })
         );
       }
+      if (config.changelogJson.enabled) {
+        for (const changelogPath of component.changelogPaths) {
+          const jsonFiles = generateSyntheticChangelogJson(
+            config,
+            changelogPath,
+            bump.newVersion,
+            today,
+            releaseEntry.propagatedFrom,
+            dryRun
+          );
+          modifiedFiles.push(...jsonFiles);
+        }
+      }
     } else {
       for (const changelogPath of component.changelogPaths) {
         changelogFiles.push(
@@ -178,6 +192,15 @@ function executeReleaseSet(sortedDirs, fullReleaseSet, config, directResults, pr
           })
         );
       }
+      if (config.changelogJson.enabled) {
+        for (const changelogPath of component.changelogPaths) {
+          const jsonFiles = generateChangelogJson(config, changelogPath, newTag, dryRun, {
+            tagPattern: buildTagPattern(component.tagPrefix),
+            includePaths: component.paths
+          });
+          modifiedFiles.push(...jsonFiles);
+        }
+      }
     }
     components.push({
       name: dir,

package/dist/esm/renderReleaseNotes.d.ts

@@ -0,0 +1,8 @@
+import type { ChangelogAudience, ChangelogEntry, ChangelogSection } from './types.ts';
+export interface RenderOptions {
+    filter?: (section: ChangelogSection) => boolean;
+    includeHeading?: boolean;
+}
+export declare function matchesAudience(audience: ChangelogAudience): (section: ChangelogSection) => boolean;
+export declare function renderReleaseNotesSingle(entry: ChangelogEntry, options?: RenderOptions): string;
+export declare function renderReleaseNotesMulti(entries: ChangelogEntry[], options?: RenderOptions): string;

package/dist/esm/renderReleaseNotes.js

@@ -0,0 +1,40 @@
+function allSections() {
+  return true;
+}
+function publicSections(section) {
+  return section.audience === "all";
+}
+function matchesAudience(audience) {
+  return audience === "dev" ? allSections : publicSections;
+}
+function renderReleaseNotesSingle(entry, options) {
+  const filter = options?.filter;
+  const includeHeading = options?.includeHeading ?? true;
+  const sections = filter !== void 0 ? entry.sections.filter(filter) : entry.sections;
+  if (sections.length === 0) {
+    return "";
+  }
+  const lines = [];
+  if (includeHeading) {
+    lines.push(`## ${entry.version} \u2014 ${entry.date}`);
+  }
+  for (const section of sections) {
+    if (lines.length > 0) {
+      lines.push("");
+    }
+    lines.push(`### ${section.title}`, "");
+    for (const item of section.items) {
+      lines.push(`- ${item.description}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function renderReleaseNotesMulti(entries, options) {
+  const parts = entries.map((entry) => renderReleaseNotesSingle(entry, options)).filter((part) => part.length > 0);
+  return parts.join("\n");
+}
+export {
+  matchesAudience,
+  renderReleaseNotesMulti,
+  renderReleaseNotesSingle
+};

package/dist/esm/resolveCommandTags.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedTag } from './resolveReleaseTags.ts';
+export declare function resolveCommandTags(only: string[] | undefined): Promise<ResolvedTag[]>;

package/dist/esm/resolveCommandTags.js

@@ -0,0 +1,36 @@
+import { basename } from "node:path";
+import { discoverWorkspaces } from "./discoverWorkspaces.js";
+import { resolveReleaseTags } from "./resolveReleaseTags.js";
+async function resolveCommandTags(only) {
+  let discoveredPaths;
+  try {
+    discoveredPaths = await discoverWorkspaces();
+  } catch (error) {
+    console.error(`Error discovering workspaces: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+  if (only !== void 0 && discoveredPaths === void 0) {
+    console.error("Error: --only is only supported for monorepo configurations");
+    process.exit(1);
+  }
+  const workspaceMap = discoveredPaths === void 0 ? void 0 : new Map(discoveredPaths.map((p) => [basename(p), p]));
+  let resolvedTags = resolveReleaseTags(workspaceMap);
+  if (resolvedTags.length === 0) {
+    console.error("Error: No release tags found on HEAD. Create tags with `release-kit tag` first.");
+    process.exit(1);
+  }
+  if (only !== void 0) {
+    const availableNames = resolvedTags.map((t) => t.dir);
+    for (const name of only) {
+      if (!availableNames.includes(name)) {
+        console.error(`Error: Unknown package "${name}" in --only. Available: ${availableNames.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    resolvedTags = resolvedTags.filter((t) => only.includes(t.dir));
+  }
+  return resolvedTags;
+}
+export {
+  resolveCommandTags
+};

package/dist/esm/resolveReleaseNotesConfig.d.ts

@@ -0,0 +1,6 @@
+import type { ReleaseNotesConfig } from './types.ts';
+export interface ResolvedReleaseNotesConfig {
+    releaseNotes: ReleaseNotesConfig;
+    changelogJsonOutputPath: string;
+}
+export declare function resolveReleaseNotesConfig(): Promise<ResolvedReleaseNotesConfig>;

package/dist/esm/resolveReleaseNotesConfig.js

@@ -0,0 +1,37 @@
+import { DEFAULT_CHANGELOG_JSON_CONFIG, DEFAULT_RELEASE_NOTES_CONFIG } from "./defaults.js";
+import { loadConfig } from "./loadConfig.js";
+import { validateConfig } from "./validateConfig.js";
+async function resolveReleaseNotesConfig() {
+  let rawConfig;
+  try {
+    rawConfig = await loadConfig();
+  } catch (error) {
+    console.warn(
+      `Warning: failed to load config; using defaults: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (rawConfig === void 0) {
+    return {
+      releaseNotes: { ...DEFAULT_RELEASE_NOTES_CONFIG },
+      changelogJsonOutputPath: DEFAULT_CHANGELOG_JSON_CONFIG.outputPath
+    };
+  }
+  const { config, errors, warnings } = validateConfig(rawConfig);
+  if (errors.length > 0) {
+    console.error("Invalid config:");
+    for (const err of errors) {
+      console.error(`  \u274C ${err}`);
+    }
+    process.exit(1);
+  }
+  for (const warning of warnings) {
+    console.warn(`  \u26A0\uFE0F  ${warning}`);
+  }
+  return {
+    releaseNotes: { ...DEFAULT_RELEASE_NOTES_CONFIG, ...config.releaseNotes },
+    changelogJsonOutputPath: config.changelogJson?.outputPath ?? DEFAULT_CHANGELOG_JSON_CONFIG.outputPath
+  };
+}
+export {
+  resolveReleaseNotesConfig
+};

package/dist/esm/sync-labels/generateCommand.d.ts

@@ -1,4 +1,4 @@
 import type { LabelDefinition } from './types.ts';
 export declare const LABELS_OUTPUT_PATH = ".github/labels.yaml";
-export declare function formatLabelsYaml(labels: LabelDefinition[]): string;
+export declare function formatLabelsYaml(labels: LabelDefinition[], presetHashes: Map<string, string>): string;
 export declare function generateCommand(): Promise<number>;

package/dist/esm/sync-labels/generateCommand.js

@@ -2,14 +2,16 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { dump } from "js-yaml";
 import { loadSyncLabelsConfig, SYNC_LABELS_CONFIG_PATH } from "./loadSyncLabelsConfig.js";
+import { hashPresetFile } from "./presets.js";
 import { resolveLabels } from "./resolveLabels.js";
 const LABELS_OUTPUT_PATH = ".github/labels.yaml";
-const GENERATED_HEADER = `# Generated by release-kit sync-labels \u2014 do not edit.
-# Source: ${SYNC_LABELS_CONFIG_PATH}
-`;
-function formatLabelsYaml(labels) {
-  const yamlBody = dump(labels, { quotingType: '"', forceQuotes: false, lineWidth: -1 });
-  return GENERATED_HEADER + yamlBody;
+function formatLabelsYaml(labels, presetHashes) {
+  const headerLines = ["# Generated by release-kit sync-labels \u2014 do not edit.", `# Source: ${SYNC_LABELS_CONFIG_PATH}`];
+  for (const [name, hash] of [...presetHashes.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+    headerLines.push(`# ${name} preset hash: ${hash}`);
+  }
+  const yamlBody = dump(labels, { quotingType: "'", forceQuotes: false, lineWidth: -1 });
+  return headerLines.join("\n") + "\n" + yamlBody;
 }
 async function generateCommand() {
   let config;
@@ -32,7 +34,11 @@ async function generateCommand() {
     console.error(`Error resolving labels: ${message}`);
     return 1;
   }
-  const content = formatLabelsYaml(labels);
+  const presetHashes = /* @__PURE__ */ new Map();
+  for (const presetName of config.presets ?? []) {
+    presetHashes.set(presetName, hashPresetFile(presetName));
+  }
+  const content = formatLabelsYaml(labels, presetHashes);
   try {
     mkdirSync(dirname(LABELS_OUTPUT_PATH), { recursive: true });
     writeFileSync(LABELS_OUTPUT_PATH, content, "utf8");

package/dist/esm/sync-labels/presets.d.ts

@@ -1,2 +1,3 @@
 import type { LabelDefinition } from './types.ts';
+export declare function hashPresetFile(presetName: string): string;
 export declare function loadPreset(presetName: string): LabelDefinition[];