@williamthorsen/release-kit 4.8.0 → 5.1.0

package/dist/esm/createGithubReleaseCommand.d.ts

@@ -0,0 +1 @@
+export declare function createGithubReleaseCommand(argv: string[]): Promise<void>;

package/dist/esm/createGithubReleaseCommand.js

@@ -0,0 +1,41 @@
+import { parseArgs, translateParseError } from "@williamthorsen/nmr-core";
+import { createGithubReleases } from "./createGithubRelease.js";
+import { parseRequestedTags } from "./parseRequestedTags.js";
+import { resolveCommandTags } from "./resolveCommandTags.js";
+import { resolveReleaseNotesConfig } from "./resolveReleaseNotesConfig.js";
+const createGithubReleaseFlagSchema = {
+  dryRun: { long: "--dry-run", type: "boolean" },
+  tags: { long: "--tags", type: "string" }
+};
+async function createGithubReleaseCommand(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs(argv, createGithubReleaseFlagSchema);
+  } catch (error) {
+    console.error(`Error: ${translateParseError(error)}`);
+    process.exit(1);
+  }
+  const { dryRun } = parsed.flags;
+  const requestedTags = parseRequestedTags(parsed.flags.tags);
+  const resolvedTags = await resolveCommandTags(requestedTags);
+  const { changelogJsonOutputPath, sectionOrder } = await resolveReleaseNotesConfig({ strictLoad: true });
+  let outcome;
+  try {
+    outcome = createGithubReleases(resolvedTags, changelogJsonOutputPath, dryRun, sectionOrder);
+  } catch (error) {
+    console.error(`Error creating GitHub Releases: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+  if (requestedTags !== void 0 && outcome.created.length === 0) {
+    console.error(
+      `Error: no GitHub Releases were created for requested tags: ${outcome.skipped.join(", ")}. Each was skipped (missing changelog entry, no all-audience content, or empty rendered body).`
+    );
+    process.exit(1);
+  }
+  if (outcome.skipped.length > 0) {
+    console.info(`Skipped ${outcome.skipped.length} tag(s) with no releasable content: ${outcome.skipped.join(", ")}.`);
+  }
+}
+export {
+  createGithubReleaseCommand
+};

package/dist/esm/decideRelease.d.ts

@@ -0,0 +1,25 @@
+import type { Commit, ReleaseType, VersionPatterns, WorkTypeConfig } from './types.ts';
+export interface DecideReleaseArgs {
+    commits: readonly Commit[];
+    force?: boolean | undefined;
+    bumpOverride: ReleaseType | undefined;
+    workTypes: Record<string, WorkTypeConfig>;
+    versionPatterns: VersionPatterns;
+    scopeAliases: Record<string, string> | undefined;
+    skipReasons: {
+        noCommits: string;
+        noBumpWorthy: string;
+    };
+}
+export type DecideReleaseResult = {
+    outcome: 'release';
+    releaseType: ReleaseType;
+    parsedCommitCount: number;
+    unparseableCommits: Commit[] | undefined;
+} | {
+    outcome: 'skip';
+    skipReason: string;
+    parsedCommitCount: number;
+    unparseableCommits: Commit[] | undefined;
+};
+export declare function decideRelease(args: DecideReleaseArgs): DecideReleaseResult;

package/dist/esm/decideRelease.js

@@ -0,0 +1,28 @@
+import { determineBumpType } from "./determineBumpType.js";
+import { parseCommitMessage } from "./parseCommitMessage.js";
+function decideRelease(args) {
+  const { commits, force = false, bumpOverride, workTypes, versionPatterns, scopeAliases, skipReasons } = args;
+  const parsedCommits = [];
+  const unparseable = [];
+  for (const commit of commits) {
+    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, scopeAliases);
+    if (parsed === void 0) {
+      unparseable.push(commit);
+    } else {
+      parsedCommits.push(parsed);
+    }
+  }
+  const parsedCommitCount = parsedCommits.length;
+  const unparseableCommits = unparseable.length > 0 ? unparseable : void 0;
+  const naturalBump = determineBumpType(parsedCommits, workTypes, versionPatterns);
+  const shouldRelease = naturalBump !== void 0 || force;
+  if (!shouldRelease) {
+    const skipReason = commits.length === 0 ? skipReasons.noCommits : skipReasons.noBumpWorthy;
+    return { outcome: "skip", skipReason, parsedCommitCount, unparseableCommits };
+  }
+  const releaseType = bumpOverride ?? naturalBump ?? "patch";
+  return { outcome: "release", releaseType, parsedCommitCount, unparseableCommits };
+}
+export {
+  decideRelease
+};

package/dist/esm/defaults.d.ts

@@ -3,3 +3,4 @@ export declare const DEFAULT_WORK_TYPES: Record<string, WorkTypeConfig>;
 export declare const DEFAULT_VERSION_PATTERNS: VersionPatterns;
 export declare const DEFAULT_CHANGELOG_JSON_CONFIG: ChangelogJsonConfig;
 export declare const DEFAULT_RELEASE_NOTES_CONFIG: ReleaseNotesConfig;
+export declare const DEFAULT_PROJECT_TAG_PREFIX = "v";

package/dist/esm/defaults.js

@@ -11,6 +11,9 @@ const DEFAULT_WORK_TYPES = {
   ci: { header: "CI" },
   deps: { header: "Dependencies", aliases: ["dep"] },
   docs: { header: "Documentation", aliases: ["doc"] },
+  ai: { header: "Agentic support" },
+  // `fmt` is retained for bump-determination (`parseCommitMessage`), even though
+  // `cliff.toml.template` skips `fmt:` commits so they never enter the changelog.
   fmt: { header: "Formatting" }
 };
 const DEFAULT_VERSION_PATTERNS = {
@@ -20,14 +23,15 @@ const DEFAULT_VERSION_PATTERNS = {
 const DEFAULT_CHANGELOG_JSON_CONFIG = {
   enabled: true,
   outputPath: ".meta/changelog.json",
-  devOnlySections: ["CI", "Dependencies", "Formatting", "Internal", "Tests", "Tooling"]
+  devOnlySections: ["Agentic support", "CI", "Dependencies", "Internal", "Refactoring", "Tests", "Tooling"]
 };
 const DEFAULT_RELEASE_NOTES_CONFIG = {
-  shouldInjectIntoReadme: false,
-  shouldCreateGithubRelease: false
+  shouldInjectIntoReadme: false
 };
+const DEFAULT_PROJECT_TAG_PREFIX = "v";
 export {
   DEFAULT_CHANGELOG_JSON_CONFIG,
+  DEFAULT_PROJECT_TAG_PREFIX,
   DEFAULT_RELEASE_NOTES_CONFIG,
   DEFAULT_VERSION_PATTERNS,
   DEFAULT_WORK_TYPES

package/dist/esm/deriveWorkspaceConfig.d.ts

@@ -0,0 +1,2 @@
+import type { WorkspaceConfig } from './types.ts';
+export declare function deriveWorkspaceConfig(workspacePath: string): WorkspaceConfig;

package/dist/esm/deriveWorkspaceConfig.js

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { isRecord } from "./typeGuards.js";
+function deriveWorkspaceConfig(workspacePath) {
+  const dir = basename(workspacePath);
+  const packageJsonPath = `${workspacePath}/package.json`;
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to read ${packageJsonPath}: ${message}`);
+  }
+  const name = isRecord(parsed) ? parsed.name : void 0;
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(`${packageJsonPath} is missing a 'name' field (required for tag derivation).`);
+  }
+  const unscopedName = stripNpmScope(name);
+  return {
+    dir,
+    name,
+    tagPrefix: `${unscopedName}-v`,
+    workspacePath,
+    packageFiles: [packageJsonPath],
+    changelogPaths: [workspacePath],
+    paths: [`${workspacePath}/**`]
+  };
+}
+function stripNpmScope(name) {
+  if (name.startsWith("@") && name.includes("/")) {
+    return name.slice(name.indexOf("/") + 1);
+  }
+  return name;
+}
+export {
+  deriveWorkspaceConfig
+};

package/dist/esm/detectUndeclaredTagPrefixes.d.ts

@@ -0,0 +1,7 @@
+export interface UndeclaredTagPrefix {
+    prefix: string;
+    tagCount: number;
+    exampleTags: string[];
+    suggestedDir: string;
+}
+export declare function detectUndeclaredTagPrefixes(knownPrefixes: readonly string[]): UndeclaredTagPrefix[];

package/dist/esm/detectUndeclaredTagPrefixes.js

@@ -0,0 +1,46 @@
+import { execFileSync } from "node:child_process";
+const EXAMPLE_TAG_LIMIT = 3;
+const CANDIDATE_TAG_PATTERN = /^(?<prefix>[a-z][a-z0-9-]*-v)\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/;
+function detectUndeclaredTagPrefixes(knownPrefixes) {
+  const known = new Set(knownPrefixes);
+  let rawOutput;
+  try {
+    rawOutput = execFileSync("git", ["tag", "--list"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch {
+    return [];
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const line of rawOutput.split("\n")) {
+    const tag = line.trim();
+    if (tag === "") continue;
+    const match = CANDIDATE_TAG_PATTERN.exec(tag);
+    if (match === null) continue;
+    const prefix = match.groups?.prefix ?? "";
+    if (prefix === "" || known.has(prefix)) continue;
+    let tags = grouped.get(prefix);
+    if (tags === void 0) {
+      tags = [];
+      grouped.set(prefix, tags);
+    }
+    tags.push(tag);
+  }
+  const results = [];
+  for (const [prefix, tags] of grouped) {
+    results.push({
+      prefix,
+      tagCount: tags.length,
+      exampleTags: tags.slice(0, EXAMPLE_TAG_LIMIT),
+      suggestedDir: stripTrailingTagMarker(prefix)
+    });
+  }
+  return results.sort((a, b) => a.prefix.localeCompare(b.prefix));
+}
+function stripTrailingTagMarker(prefix) {
+  return prefix.endsWith("-v") ? prefix.slice(0, -2) : prefix;
+}
+export {
+  detectUndeclaredTagPrefixes
+};

package/dist/esm/generateChangelogs.d.ts

@@ -1,5 +1,5 @@
 import type { ReleaseConfig } from './types.ts';
-export declare function buildTagPattern(tagPrefix: string): string;
+export declare function buildTagPattern(tagPrefixes: readonly string[]): string;
 export interface GenerateChangelogOptions {
     tagPattern?: string;
     includePaths?: string[];

package/dist/esm/generateChangelogs.js

@@ -3,8 +3,19 @@ import { copyFileSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { resolveCliffConfigPath } from "./resolveCliffConfigPath.js";
-function buildTagPattern(tagPrefix) {
-  return `${tagPrefix}[0-9].*`;
+function buildTagPattern(tagPrefixes) {
+  if (tagPrefixes.length === 0) {
+    throw new Error("buildTagPattern: tagPrefixes must contain at least one entry");
+  }
+  if (tagPrefixes.length === 1) {
+    const single = tagPrefixes[0] ?? "";
+    return `${single}[0-9].*`;
+  }
+  const escaped = tagPrefixes.map(escapeRegex);
+  return `(${escaped.join("|")})[0-9].*`;
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
 }
 function generateChangelog(config, changelogPath, tag, dryRun, options) {
   const resolvedConfigPath = resolveCliffConfigPath(config.cliffConfigPath, import.meta.url);
@@ -41,7 +52,7 @@ function generateChangelog(config, changelogPath, tag, dryRun, options) {
   }
 }
 function generateChangelogs(config, tag, dryRun) {
-  const tagPattern = buildTagPattern(config.tagPrefix);
+  const tagPattern = buildTagPattern([config.tagPrefix]);
   const results = [];
   for (const changelogPath of config.changelogPaths) {
     results.push(...generateChangelog(config, changelogPath, tag, dryRun, { tagPattern }));

package/dist/esm/getCommitsSinceTarget.d.ts

@@ -1,5 +1,5 @@
 import type { Commit } from './types.ts';
-export declare function getCommitsSinceTarget(tagPrefix: string, paths?: string[]): {
+export declare function getCommitsSinceTarget(tagPrefixes: readonly string[], paths?: string[]): {
     tag: string | undefined;
     commits: Commit[];
 };

package/dist/esm/getCommitsSinceTarget.js

@@ -6,9 +6,13 @@ function isNoTagError(err) {
 function errorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
-function findLatestTag(tagPrefix) {
+function findLatestTag(tagPrefixes) {
+  if (tagPrefixes.length === 0) {
+    throw new Error("findLatestTag: tagPrefixes must contain at least one entry");
+  }
+  const matchArgs = tagPrefixes.map((prefix) => `--match=${prefix}*`);
   try {
-    const tagResult = execFileSync("git", ["describe", "--tags", "--abbrev=0", `--match=${tagPrefix}*`], {
+    const tagResult = execFileSync("git", ["describe", "--tags", "--abbrev=0", ...matchArgs], {
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
@@ -35,8 +39,8 @@ function parseLogOutput(logOutput) {
   }
   return commits;
 }
-function getCommitsSinceTarget(tagPrefix, paths) {
-  const tag = findLatestTag(tagPrefix);
+function getCommitsSinceTarget(tagPrefixes, paths) {
+  const tag = findLatestTag(tagPrefixes);
   const range = tag === void 0 ? "HEAD" : `${tag}..HEAD`;
   const format = `%s${FIELD_SEPARATOR}%H`;
   const args = ["log", range, `--pretty=format:${format}`];

package/dist/esm/index.d.ts

@@ -1,39 +1,2 @@
-export type { CreateTagsOptions } from './createTags.ts';
-export type { PackageManager } from './detectPackageManager.ts';
-export type { GenerateChangelogOptions } from './generateChangelogs.ts';
-export type { PublishOptions } from './publish.ts';
-export type { ReleasePrepareOptions } from './releasePrepare.ts';
-export type { ResolvedTag } from './resolveReleaseTags.ts';
-export type { LabelDefinition, SyncLabelsConfig } from './sync-labels/types.ts';
-export type { BumpResult, ChangelogAudience, ChangelogEntry, ChangelogItem, ChangelogJsonConfig, ChangelogSection, Commit, ComponentConfig, ComponentOverride, ComponentPrepareResult, MonorepoReleaseConfig, ParsedCommit, PrepareResult, ReleaseConfig, ReleaseKitConfig, ReleaseNotesConfig, ReleaseType, VersionPatterns, WorkTypeConfig, } from './types.ts';
-export { DEFAULT_CHANGELOG_JSON_CONFIG, DEFAULT_RELEASE_NOTES_CONFIG, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES, } from './defaults.ts';
-export { buildReleaseSummary } from './buildReleaseSummary.ts';
-export { bumpAllVersions } from './bumpAllVersions.ts';
-export { bumpVersion } from './bumpVersion.ts';
-export { commitCommand } from './commitCommand.ts';
-export { component } from './component.ts';
-export type { CreateGithubReleaseOptions } from './createGithubRelease.ts';
-export { createGithubRelease, createGithubReleases } from './createGithubRelease.ts';
-export { createTags } from './createTags.ts';
-export { deleteFileIfExists } from './deleteFileIfExists.ts';
-export { detectPackageManager } from './detectPackageManager.ts';
-export { determineBumpType } from './determineBumpType.ts';
-export { discoverWorkspaces } from './discoverWorkspaces.ts';
-export { generateChangelogJson, generateSyntheticChangelogJson } from './generateChangelogJson.ts';
-export { generateChangelog, generateChangelogs } from './generateChangelogs.ts';
-export { getCommitsSinceTarget } from './getCommitsSinceTarget.ts';
-export { injectReleaseNotesIntoReadme, resolveReadmePath } from './injectReleaseNotesIntoReadme.ts';
-export { injectSection } from './injectSection.ts';
-export { COMMIT_PREPROCESSOR_PATTERNS, parseCommitMessage } from './parseCommitMessage.ts';
-export { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE, writeReleaseTags } from './prepareCommand.ts';
-export { publishPackage } from './publish.ts';
-export type { PushReleaseOptions } from './pushRelease.ts';
-export { pushRelease } from './pushRelease.ts';
-export { releasePrepare } from './releasePrepare.ts';
-export { releasePrepareMono } from './releasePrepareMono.ts';
-export type { RenderOptions } from './renderReleaseNotes.ts';
-export { matchesAudience, renderReleaseNotesMulti, renderReleaseNotesSingle } from './renderReleaseNotes.ts';
-export { reportPrepare } from './reportPrepare.ts';
-export { resolveCommandTags } from './resolveCommandTags.ts';
-export { resolveReleaseTags } from './resolveReleaseTags.ts';
-export { stripScope } from './stripScope.ts';
+export type { SyncLabelsConfig } from './sync-labels/types.ts';
+export type { ReleaseKitConfig } from './types.ts';

package/dist/esm/index.js

@@ -1,75 +0,0 @@
-import {
-  DEFAULT_CHANGELOG_JSON_CONFIG,
-  DEFAULT_RELEASE_NOTES_CONFIG,
-  DEFAULT_VERSION_PATTERNS,
-  DEFAULT_WORK_TYPES
-} from "./defaults.js";
-import { buildReleaseSummary } from "./buildReleaseSummary.js";
-import { bumpAllVersions } from "./bumpAllVersions.js";
-import { bumpVersion } from "./bumpVersion.js";
-import { commitCommand } from "./commitCommand.js";
-import { component } from "./component.js";
-import { createGithubRelease, createGithubReleases } from "./createGithubRelease.js";
-import { createTags } from "./createTags.js";
-import { deleteFileIfExists } from "./deleteFileIfExists.js";
-import { detectPackageManager } from "./detectPackageManager.js";
-import { determineBumpType } from "./determineBumpType.js";
-import { discoverWorkspaces } from "./discoverWorkspaces.js";
-import { generateChangelogJson, generateSyntheticChangelogJson } from "./generateChangelogJson.js";
-import { generateChangelog, generateChangelogs } from "./generateChangelogs.js";
-import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
-import { injectReleaseNotesIntoReadme, resolveReadmePath } from "./injectReleaseNotesIntoReadme.js";
-import { injectSection } from "./injectSection.js";
-import { COMMIT_PREPROCESSOR_PATTERNS, parseCommitMessage } from "./parseCommitMessage.js";
-import { RELEASE_SUMMARY_FILE, RELEASE_TAGS_FILE, writeReleaseTags } from "./prepareCommand.js";
-import { publishPackage } from "./publish.js";
-import { pushRelease } from "./pushRelease.js";
-import { releasePrepare } from "./releasePrepare.js";
-import { releasePrepareMono } from "./releasePrepareMono.js";
-import { matchesAudience, renderReleaseNotesMulti, renderReleaseNotesSingle } from "./renderReleaseNotes.js";
-import { reportPrepare } from "./reportPrepare.js";
-import { resolveCommandTags } from "./resolveCommandTags.js";
-import { resolveReleaseTags } from "./resolveReleaseTags.js";
-import { stripScope } from "./stripScope.js";
-export {
-  COMMIT_PREPROCESSOR_PATTERNS,
-  DEFAULT_CHANGELOG_JSON_CONFIG,
-  DEFAULT_RELEASE_NOTES_CONFIG,
-  DEFAULT_VERSION_PATTERNS,
-  DEFAULT_WORK_TYPES,
-  RELEASE_SUMMARY_FILE,
-  RELEASE_TAGS_FILE,
-  buildReleaseSummary,
-  bumpAllVersions,
-  bumpVersion,
-  commitCommand,
-  component,
-  createGithubRelease,
-  createGithubReleases,
-  createTags,
-  deleteFileIfExists,
-  detectPackageManager,
-  determineBumpType,
-  discoverWorkspaces,
-  generateChangelog,
-  generateChangelogJson,
-  generateChangelogs,
-  generateSyntheticChangelogJson,
-  getCommitsSinceTarget,
-  injectReleaseNotesIntoReadme,
-  injectSection,
-  matchesAudience,
-  parseCommitMessage,
-  publishPackage,
-  pushRelease,
-  releasePrepare,
-  releasePrepareMono,
-  renderReleaseNotesMulti,
-  renderReleaseNotesSingle,
-  reportPrepare,
-  resolveCommandTags,
-  resolveReadmePath,
-  resolveReleaseTags,
-  stripScope,
-  writeReleaseTags
-};

package/dist/esm/init/initCommand.js

@@ -1,4 +1,4 @@
-import { printError, printStep, printSuccess, reportWriteResult } from "@williamthorsen/node-monorepo-core";
+import { printError, printStep, printSuccess, reportWriteResult } from "@williamthorsen/nmr-core";
 import { hasPackageJson, isGitRepo, usesPnpm } from "./checks.js";
 import { detectRepoType } from "./detectRepoType.js";
 import { scaffoldFiles } from "./scaffold.js";

package/dist/esm/init/scaffold.d.ts

@@ -1,4 +1,4 @@
-import type { WriteResult } from '@williamthorsen/node-monorepo-core';
+import type { WriteResult } from '@williamthorsen/nmr-core';
 import type { RepoType } from './detectRepoType.ts';
 interface ScaffoldOptions {
     repoType: RepoType;

package/dist/esm/init/scaffold.js

@@ -1,8 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { writeFileWithCheck } from "@williamthorsen/node-monorepo-core";
-import { findPackageRoot } from "../findPackageRoot.js";
-import { publishWorkflow, releaseConfigScript, releaseWorkflow } from "./templates.js";
+import { findPackageRoot, writeFileWithCheck } from "@williamthorsen/nmr-core";
+import { createGithubReleaseWorkflow, publishWorkflow, releaseConfigScript, releaseWorkflow } from "./templates.js";
 function copyCliffTemplate(dryRun, overwrite) {
   const destPath = ".config/git-cliff.toml";
   const root = findPackageRoot(import.meta.url);
@@ -21,8 +20,12 @@ function copyCliffTemplate(dryRun, overwrite) {
 }
 function scaffoldFiles({ repoType, dryRun, overwrite, withConfig }) {
   const results = [
-    writeFileWithCheck(".github/workflows/release.yaml", releaseWorkflow(repoType), { dryRun, overwrite }),
-    writeFileWithCheck(".github/workflows/publish.yaml", publishWorkflow(repoType), { dryRun, overwrite })
+    writeFileWithCheck(".github/workflows/create-github-release.yaml", createGithubReleaseWorkflow(repoType), {
+      dryRun,
+      overwrite
+    }),
+    writeFileWithCheck(".github/workflows/publish.yaml", publishWorkflow(repoType), { dryRun, overwrite }),
+    writeFileWithCheck(".github/workflows/release.yaml", releaseWorkflow(repoType), { dryRun, overwrite })
   ];
   if (withConfig) {
     results.push(

package/dist/esm/init/templates.d.ts

@@ -1,4 +1,5 @@
 import type { RepoType } from './detectRepoType.ts';
 export declare function releaseConfigScript(repoType: RepoType): string;
 export declare function publishWorkflow(repoType: RepoType): string;
+export declare function createGithubReleaseWorkflow(repoType: RepoType): string;
 export declare function releaseWorkflow(repoType: RepoType): string;

package/dist/esm/init/templates.js

@@ -3,8 +3,12 @@ function releaseConfigScript(repoType) {
     return `import type { ReleaseKitConfig } from '@williamthorsen/release-kit';
 
 const config: ReleaseKitConfig = {
-  // Uncomment to exclude components from release processing:
-  // components: [
+  releaseNotes: {
+    shouldInjectIntoReadme: true,
+  },
+
+  // Uncomment to exclude workspaces from release processing:
+  // workspaces: [
   //   { dir: 'my-package', shouldExclude: true },
   // ],
 
@@ -23,6 +27,10 @@ export default config;
   return `import type { ReleaseKitConfig } from '@williamthorsen/release-kit';
 
 const config: ReleaseKitConfig = {
+  releaseNotes: {
+    shouldInjectIntoReadme: true,
+  },
+
   // Formatting: prettier is auto-detected. Set formatCommand to override.
 
   // Uncomment to override the default version patterns:
@@ -54,6 +62,27 @@ jobs:
     uses: williamthorsen/node-monorepo-tools/.github/workflows/publish.reusable.yaml@workflow/publish-v1
     with:
       provenance: true
+      tags: \${{ github.ref_name }}
+`;
+}
+function createGithubReleaseWorkflow(repoType) {
+  const tagPattern = repoType === "monorepo" ? "'*-v[0-9]*.[0-9]*.[0-9]*'" : "'v[0-9]*.[0-9]*.[0-9]*'";
+  return `# yaml-language-server: $schema=https://json.schemastore.org/github-workflow.json
+name: Create GitHub Release
+
+on:
+  push:
+    tags:
+      - ${tagPattern}
+
+permissions:
+  contents: write
+
+jobs:
+  create-github-release:
+    uses: williamthorsen/node-monorepo-tools/.github/workflows/create-github-release.reusable.yaml@workflow/create-github-release-v1
+    with:
+      tag: \${{ github.ref_name }}
 `;
 }
 function releaseWorkflow(repoType) {
@@ -65,7 +94,7 @@ on:
   workflow_dispatch:
     inputs:
       only:
-        description: 'Components to release (comma-separated, leave empty for all)'
+        description: 'Workspaces to release (comma-separated, leave empty for all)'
         required: false
         type: string
       bump:
@@ -78,7 +107,7 @@ on:
           - minor
           - major
       force:
-        description: 'Force a release even when there are no commits since the last tag (requires --bump)'
+        description: 'Force a release even when no commits or no bump-worthy commits exist (defaults to patch; combine with --bump for a different level)'
         required: false
         type: boolean
         default: false
@@ -112,7 +141,7 @@ on:
           - minor
           - major
       force:
-        description: 'Force a release even when there are no commits since the last tag (requires --bump)'
+        description: 'Force a release even when no commits or no bump-worthy commits exist (defaults to patch; combine with --bump for a different level)'
         required: false
         type: boolean
         default: false
@@ -130,6 +159,7 @@ jobs:
 `;
 }
 export {
+  createGithubReleaseWorkflow,
   publishWorkflow,
   releaseConfigScript,
   releaseWorkflow

package/dist/esm/injectReleaseNotesIntoReadme.d.ts

@@ -1,2 +1,7 @@
-export declare function injectReleaseNotesIntoReadme(readmePath: string, changelogJsonPath: string, tag: string): string | undefined;
+export interface RenderedInjectedReadme {
+    injectedReadme: string;
+    releaseNotesMarkdown: string;
+}
+export declare function renderInjectedReadme(readme: string, changelogJsonPath: string, tag: string, sectionOrder?: string[]): RenderedInjectedReadme | undefined;
+export declare function injectReleaseNotesIntoReadme(readmePath: string, changelogJsonPath: string, tag: string, sectionOrder?: string[]): string | undefined;
 export declare function resolveReadmePath(workspacePath: string): string | undefined;

package/dist/esm/injectReleaseNotesIntoReadme.js

@@ -3,12 +3,11 @@ import { join } from "node:path";
 import { extractVersion, readChangelogEntries } from "./changelogJsonUtils.js";
 import { injectSection } from "./injectSection.js";
 import { matchesAudience, renderReleaseNotesSingle } from "./renderReleaseNotes.js";
-function injectReleaseNotesIntoReadme(readmePath, changelogJsonPath, tag) {
+function renderInjectedReadme(readme, changelogJsonPath, tag, sectionOrder) {
   if (!existsSync(changelogJsonPath)) {
     console.warn(`Warning: ${changelogJsonPath} not found; skipping README injection`);
     return void 0;
   }
-  const originalReadme = readFileSync(readmePath, "utf8");
   const version = extractVersion(tag);
   const entries = readChangelogEntries(changelogJsonPath);
   if (entries === void 0) {
@@ -20,16 +19,29 @@ function injectReleaseNotesIntoReadme(readmePath, changelogJsonPath, tag) {
     console.warn(`Warning: no changelog entry for version ${version}; skipping README injection`);
     return void 0;
   }
-  const releaseNotesMarkdown = renderReleaseNotesSingle(entry, {
+  const renderedSections = renderReleaseNotesSingle(entry, {
     filter: matchesAudience("all"),
-    includeHeading: false
+    includeHeading: false,
+    ...sectionOrder === void 0 ? {} : { sectionOrder }
   });
-  if (releaseNotesMarkdown.trimEnd().length === 0) {
+  if (renderedSections.trimEnd().length === 0) {
     console.warn(`Warning: no user-facing release notes for version ${version}; skipping README injection`);
     return void 0;
   }
-  const injected = injectSection(originalReadme, "release-notes", releaseNotesMarkdown.trimEnd());
-  writeFileSync(readmePath, injected, "utf8");
+  const labeledHeading = `## Release notes \u2014 v${version} (${entry.date})`;
+  const releaseNotesMarkdown = `${labeledHeading}
+
+${renderedSections.trimEnd()}`;
+  const injectedReadme = injectSection(readme, "release-notes", releaseNotesMarkdown);
+  return { injectedReadme, releaseNotesMarkdown };
+}
+function injectReleaseNotesIntoReadme(readmePath, changelogJsonPath, tag, sectionOrder) {
+  const originalReadme = readFileSync(readmePath, "utf8");
+  const rendered = renderInjectedReadme(originalReadme, changelogJsonPath, tag, sectionOrder);
+  if (rendered === void 0) {
+    return void 0;
+  }
+  writeFileSync(readmePath, rendered.injectedReadme, "utf8");
   return originalReadme;
 }
 function resolveReadmePath(workspacePath) {
@@ -38,5 +50,6 @@ function resolveReadmePath(workspacePath) {
 }
 export {
   injectReleaseNotesIntoReadme,
+  renderInjectedReadme,
   resolveReadmePath
 };

package/dist/esm/loadConfig.d.ts

@@ -1,5 +1,15 @@
-import type { MonorepoReleaseConfig, ReleaseConfig, ReleaseKitConfig } from './types.ts';
+import type { MonorepoReleaseConfig, ReleaseConfig, ReleaseKitConfig, WorkTypeConfig } from './types.ts';
+export declare const ROOT_PACKAGE_JSON_PATH = "package.json";
+export declare function readRootPackageVersion(): {
+    exists: boolean;
+    version: string | undefined;
+};
 export declare const CONFIG_FILE_PATH = ".config/release-kit.config.ts";
 export declare function loadConfig(): Promise<unknown>;
-export declare function mergeMonorepoConfig(discoveredPaths: string[], userConfig: ReleaseKitConfig | undefined): MonorepoReleaseConfig;
+export interface RootPackageInfo {
+    exists: boolean;
+    version: string | undefined;
+}
+export declare function mergeMonorepoConfig(discoveredPaths: string[], userConfig: ReleaseKitConfig | undefined, rootPackage?: RootPackageInfo): MonorepoReleaseConfig;
 export declare function mergeSinglePackageConfig(userConfig: ReleaseKitConfig | undefined): ReleaseConfig;
+export declare function resolveWorkTypes(userWorkTypes?: Record<string, WorkTypeConfig>): Record<string, WorkTypeConfig>;