@williamthorsen/release-kit 4.5.1 → 4.7.0

package/dist/esm/bin/release-kit.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
 import { commitCommand } from "../commitCommand.js";
+import { githubReleaseCommand } from "../githubReleaseCommand.js";
 import { initCommand } from "../init/initCommand.js";
 import { prepareCommand } from "../prepareCommand.js";
 import { publishCommand } from "../publishCommand.js";
@@ -14,12 +15,13 @@ function showUsage() {
 Usage: release-kit <command> [options]
 
 Commands:
-  prepare       Run release preparation (auto-discovers workspaces)
-  commit        Stage changes and create the release commit
-  tag           Create annotated git tags from the tags file
-  publish       Publish packages with release tags on HEAD
-  init          Initialize release-kit in the current repository
-  sync-labels   Manage GitHub label synchronization
+  prepare          Run release preparation (auto-discovers workspaces)
+  commit           Stage changes and create the release commit
+  tag              Create annotated git tags from the tags file
+  publish          Publish packages with release tags on HEAD
+  github-release   Create GitHub Releases from changelog.json for tags on HEAD
+  init             Initialize release-kit in the current repository
+  sync-labels      Manage GitHub label synchronization
 
 Options:
   --dry-run     Preview changes without writing files
@@ -97,6 +99,7 @@ Run release preparation with automatic workspace discovery.
 Options:
   --dry-run             Run without modifying any files
   --bump=major|minor|patch  Override the bump type for all components
+  --no-git-checks, -n   Skip the clean-working-tree check
   --only=name1,name2    Only process the named components (comma-separated, monorepo only)
   --help, -h            Show this help message
 `);
@@ -125,6 +128,18 @@ Options:
   --help, -h         Show this help message
 `);
 }
+function showGithubReleaseHelp() {
+  console.info(`
+Usage: release-kit github-release [options]
+
+Create GitHub Releases from changelog.json for tags on HEAD.
+
+Options:
+  --dry-run              Preview without creating releases
+  --only=name1,name2     Only create releases for the named packages (comma-separated, monorepo only)
+  --help, -h             Show this help message
+`);
+}
 function showPublishHelp() {
   console.info(`
 Usage: release-kit publish [options]
@@ -179,6 +194,14 @@ if (command === "tag") {
   tagCommand(flags);
   process.exit(0);
 }
+if (command === "github-release") {
+  if (flags.some((f) => f === "--help" || f === "-h")) {
+    showGithubReleaseHelp();
+    process.exit(0);
+  }
+  await githubReleaseCommand(flags);
+  process.exit(0);
+}
 if (command === "publish") {
   if (flags.some((f) => f === "--help" || f === "-h")) {
     showPublishHelp();

package/dist/esm/changelogJsonUtils.d.ts

@@ -0,0 +1,4 @@
+import type { ChangelogEntry } from './types.ts';
+export declare function isChangelogEntry(value: unknown): value is ChangelogEntry;
+export declare function extractVersion(tag: string): string;
+export declare function readChangelogEntries(filePath: string): ChangelogEntry[] | undefined;

package/dist/esm/changelogJsonUtils.js

@@ -0,0 +1,29 @@
+import { existsSync, readFileSync } from "node:fs";
+import { isRecord, isUnknownArray } from "./typeGuards.js";
+function isChangelogEntry(value) {
+  return isRecord(value) && typeof value.version === "string" && typeof value.date === "string" && isUnknownArray(value.sections);
+}
+function extractVersion(tag) {
+  const match = /(\d+\.\d+\.\d+.*)$/.exec(tag);
+  return match?.[1] ?? tag;
+}
+function readChangelogEntries(filePath) {
+  if (!existsSync(filePath)) {
+    return void 0;
+  }
+  try {
+    const content = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(content);
+    if (!isUnknownArray(parsed)) {
+      return void 0;
+    }
+    return parsed.filter(isChangelogEntry);
+  } catch {
+    return void 0;
+  }
+}
+export {
+  extractVersion,
+  isChangelogEntry,
+  readChangelogEntries
+};

package/dist/esm/createGithubRelease.d.ts

@@ -0,0 +1,11 @@
+import type { ReleaseNotesConfig } from './types.ts';
+export interface CreateGithubReleaseOptions {
+    tag: string;
+    changelogJsonPath: string;
+    dryRun: boolean;
+}
+export declare function createGithubRelease(options: CreateGithubReleaseOptions): boolean;
+export declare function createGithubReleases(tags: Array<{
+    tag: string;
+    workspacePath: string;
+}>, releaseNotes: ReleaseNotesConfig, changelogJsonOutputPath: string, dryRun: boolean): void;

package/dist/esm/createGithubRelease.js

@@ -0,0 +1,60 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { extractVersion, readChangelogEntries } from "./changelogJsonUtils.js";
+import { matchesAudience, renderReleaseNotesSingle } from "./renderReleaseNotes.js";
+function createGithubRelease(options) {
+  const { tag, changelogJsonPath, dryRun } = options;
+  if (!existsSync(changelogJsonPath)) {
+    console.warn(`Warning: ${changelogJsonPath} not found; skipping GitHub Release creation`);
+    return false;
+  }
+  const version = extractVersion(tag);
+  const entries = readChangelogEntries(changelogJsonPath);
+  if (entries === void 0) {
+    console.warn(`Warning: could not parse ${changelogJsonPath}; skipping GitHub Release creation`);
+    return false;
+  }
+  const entry = entries.find((e) => e.version === version);
+  if (entry === void 0) {
+    console.warn(`Warning: no changelog entry for version ${version}; skipping GitHub Release creation`);
+    return false;
+  }
+  if (!entry.sections.some(matchesAudience("all"))) {
+    return false;
+  }
+  const body = renderReleaseNotesSingle(entry, {
+    filter: matchesAudience("all"),
+    includeHeading: false
+  });
+  if (body.trim() === "") {
+    return false;
+  }
+  const args = ["release", "create", tag, "--title", tag, "--notes", body];
+  if (dryRun) {
+    console.info(`[dry-run] Would run: gh ${args.join(" ")}`);
+    return true;
+  }
+  try {
+    execFileSync("gh", args, { stdio: "inherit" });
+    return true;
+  } catch (error) {
+    console.warn(
+      `Warning: failed to create GitHub Release for ${tag}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+}
+function createGithubReleases(tags, releaseNotes, changelogJsonOutputPath, dryRun) {
+  if (!releaseNotes.shouldCreateGithubRelease) {
+    return;
+  }
+  for (const { tag, workspacePath } of tags) {
+    const changelogJsonPath = join(workspacePath, changelogJsonOutputPath);
+    createGithubRelease({ tag, changelogJsonPath, dryRun });
+  }
+}
+export {
+  createGithubRelease,
+  createGithubReleases
+};

package/dist/esm/defaults.d.ts

@@ -1,3 +1,5 @@
-import type { VersionPatterns, WorkTypeConfig } from './types.ts';
+import type { ChangelogJsonConfig, ReleaseNotesConfig, VersionPatterns, WorkTypeConfig } from './types.ts';
 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;

package/dist/esm/defaults.js

@@ -1,8 +1,11 @@
 const DEFAULT_WORK_TYPES = {
   fix: { header: "Bug fixes", aliases: ["bugfix"] },
+  deprecate: { header: "Deprecated" },
   feat: { header: "Features", aliases: ["feature"] },
   internal: { header: "Internal" },
+  perf: { header: "Performance", aliases: ["performance"] },
   refactor: { header: "Refactoring" },
+  sec: { header: "Security", aliases: ["security"] },
   tests: { header: "Tests", aliases: ["test"] },
   tooling: { header: "Tooling" },
   ci: { header: "CI" },
@@ -14,7 +17,18 @@ const DEFAULT_VERSION_PATTERNS = {
   major: ["!"],
   minor: ["feat"]
 };
+const DEFAULT_CHANGELOG_JSON_CONFIG = {
+  enabled: true,
+  outputPath: ".meta/changelog.json",
+  devOnlySections: ["CI", "Dependencies", "Formatting", "Internal", "Tests", "Tooling"]
+};
+const DEFAULT_RELEASE_NOTES_CONFIG = {
+  shouldInjectIntoReadme: false,
+  shouldCreateGithubRelease: false
+};
 export {
+  DEFAULT_CHANGELOG_JSON_CONFIG,
+  DEFAULT_RELEASE_NOTES_CONFIG,
   DEFAULT_VERSION_PATTERNS,
   DEFAULT_WORK_TYPES
 };

package/dist/esm/generateChangelogJson.d.ts

@@ -0,0 +1,7 @@
+import type { GenerateChangelogOptions } from './generateChangelogs.ts';
+import type { ReleaseConfig } from './types.ts';
+export declare function generateChangelogJson(config: Pick<ReleaseConfig, 'cliffConfigPath' | 'changelogJson'>, changelogPath: string, tag: string, dryRun: boolean, options?: GenerateChangelogOptions): string[];
+export declare function generateSyntheticChangelogJson(config: Pick<ReleaseConfig, 'changelogJson'>, changelogPath: string, newVersion: string, date: string, propagatedFrom: Array<{
+    packageName: string;
+    newVersion: string;
+}>, dryRun: boolean): string[];

package/dist/esm/generateChangelogJson.js

@@ -0,0 +1,196 @@
+import { execFileSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import stringify from "json-stringify-pretty-compact";
+import { extractVersion, isChangelogEntry } from "./changelogJsonUtils.js";
+import { resolveCliffConfigPath } from "./resolveCliffConfigPath.js";
+import { isRecord, isUnknownArray } from "./typeGuards.js";
+function generateChangelogJson(config, changelogPath, tag, dryRun, options) {
+  const outputFile = join(changelogPath, config.changelogJson.outputPath);
+  if (dryRun) {
+    return [outputFile];
+  }
+  const resolvedConfigPath = resolveCliffConfigPath(config.cliffConfigPath, import.meta.url);
+  let cliffConfigPath = resolvedConfigPath;
+  let tempDir;
+  if (resolvedConfigPath.endsWith(".template")) {
+    tempDir = mkdtempSync(join(tmpdir(), "cliff-"));
+    cliffConfigPath = join(tempDir, "cliff.toml");
+    copyFileSync(resolvedConfigPath, cliffConfigPath);
+  }
+  const args = ["--config", cliffConfigPath, "--context", "--tag", tag];
+  if (options?.tagPattern !== void 0) {
+    args.push("--tag-pattern", options.tagPattern);
+  }
+  for (const includePath of options?.includePaths ?? []) {
+    args.push("--include-path", includePath);
+  }
+  try {
+    const contextJson = execFileSync("npx", ["--yes", "git-cliff", ...args], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "inherit"]
+    });
+    const releases = parseCliffContext(contextJson);
+    const devOnlySections = new Set(config.changelogJson.devOnlySections);
+    const entries = transformReleases(releases, devOnlySections);
+    const existingEntries = readExistingEntries(outputFile);
+    const merged = mergeEntries(entries, existingEntries);
+    mkdirSync(dirname(outputFile), { recursive: true });
+    writeFileSync(outputFile, stringify(merged, { maxLength: 100 }) + "\n", "utf8");
+    return [outputFile];
+  } catch (error) {
+    throw new Error(
+      `Failed to generate changelog JSON for ${outputFile}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  } finally {
+    if (tempDir !== void 0) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+}
+function generateSyntheticChangelogJson(config, changelogPath, newVersion, date, propagatedFrom, dryRun) {
+  const outputFile = join(changelogPath, config.changelogJson.outputPath);
+  if (dryRun) {
+    return [outputFile];
+  }
+  const items = propagatedFrom.map((dep) => ({
+    description: `Bumped \`${dep.packageName}\` to ${dep.newVersion}`
+  }));
+  const entry = {
+    version: newVersion,
+    date,
+    sections: [{ title: "Dependency updates", audience: "dev", items }]
+  };
+  const existingEntries = readExistingEntries(outputFile);
+  const merged = mergeEntries([entry], existingEntries);
+  mkdirSync(dirname(outputFile), { recursive: true });
+  writeFileSync(outputFile, stringify(merged, { maxLength: 100 }) + "\n", "utf8");
+  return [outputFile];
+}
+function parseCliffContext(json) {
+  const parsed = JSON.parse(json);
+  if (!isUnknownArray(parsed)) {
+    throw new TypeError("Expected git-cliff --context output to be an array");
+  }
+  return parsed.map(toCliffContextRelease);
+}
+function toCliffContextRelease(value) {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const release = {};
+  if (typeof value.version === "string") {
+    release.version = value.version;
+  }
+  if (typeof value.timestamp === "number") {
+    release.timestamp = value.timestamp;
+  }
+  if (isUnknownArray(value.commits)) {
+    release.commits = value.commits.map(toCliffContextCommit);
+  }
+  return release;
+}
+function toCliffContextCommit(value) {
+  if (!isRecord(value)) {
+    return { message: "" };
+  }
+  const commit = {
+    message: typeof value.message === "string" ? value.message : ""
+  };
+  if (typeof value.group === "string") {
+    commit.group = value.group;
+  }
+  return commit;
+}
+function transformReleases(releases, devOnlySections) {
+  const entries = [];
+  for (const release of releases) {
+    if (release.version === void 0) {
+      continue;
+    }
+    const version = extractVersion(release.version);
+    const date = release.timestamp !== void 0 ? new Date(release.timestamp * 1e3).toISOString().slice(0, 10) : "unreleased";
+    const sectionMap = /* @__PURE__ */ new Map();
+    for (const commit of release.commits ?? []) {
+      const group = commit.group ?? "Other";
+      const description = extractDescription(commit.message);
+      let items = sectionMap.get(group);
+      if (items === void 0) {
+        items = [];
+        sectionMap.set(group, items);
+      }
+      items.push({ description });
+    }
+    const sections = [];
+    for (const [title, items] of sectionMap) {
+      if (items.length === 0) {
+        continue;
+      }
+      sections.push({
+        title,
+        audience: devOnlySections.has(title) ? "dev" : "all",
+        items
+      });
+    }
+    if (sections.length > 0) {
+      entries.push({ version, date, sections });
+    }
+  }
+  return entries;
+}
+function extractDescription(message) {
+  const firstLine = message.split("\n")[0] ?? message;
+  const afterColon = firstLine.split(": ").slice(1).join(": ");
+  if (afterColon.length > 0) {
+    return afterColon.charAt(0).toUpperCase() + afterColon.slice(1);
+  }
+  return firstLine;
+}
+function readExistingEntries(filePath) {
+  if (!existsSync(filePath)) {
+    return [];
+  }
+  try {
+    const content = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(content);
+    if (!isUnknownArray(parsed)) {
+      return [];
+    }
+    return parsed.filter(isChangelogEntry);
+  } catch (error) {
+    console.warn(
+      `Warning: could not parse existing ${filePath}: ${error instanceof Error ? error.message : String(error)}; treating as empty`
+    );
+    return [];
+  }
+}
+function mergeEntries(newEntries, existingEntries) {
+  const versionMap = /* @__PURE__ */ new Map();
+  for (const entry of existingEntries) {
+    versionMap.set(entry.version, entry);
+  }
+  for (const entry of newEntries) {
+    versionMap.set(entry.version, entry);
+  }
+  return [...versionMap.values()].sort((a, b) => compareVersionsDescending(a.version, b.version));
+}
+function parseVersionParts(version) {
+  return version.split(".").map((s) => {
+    const n = Number(s);
+    return Number.isNaN(n) ? 0 : n;
+  });
+}
+function compareVersionsDescending(a, b) {
+  const partsA = parseVersionParts(a);
+  const partsB = parseVersionParts(b);
+  for (let i = 0; i < 3; i++) {
+    const diff = (partsB[i] ?? 0) - (partsA[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+export {
+  generateChangelogJson,
+  generateSyntheticChangelogJson
+};

package/dist/esm/generateChangelogs.js

@@ -1,10 +1,20 @@
 import { execFileSync } from "node:child_process";
+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 generateChangelog(config, changelogPath, tag, dryRun, options) {
-  const cliffConfigPath = resolveCliffConfigPath(config.cliffConfigPath, import.meta.url);
+  const resolvedConfigPath = resolveCliffConfigPath(config.cliffConfigPath, import.meta.url);
+  let cliffConfigPath = resolvedConfigPath;
+  let tempDir;
+  if (resolvedConfigPath.endsWith(".template")) {
+    tempDir = mkdtempSync(join(tmpdir(), "cliff-"));
+    cliffConfigPath = join(tempDir, "cliff.toml");
+    copyFileSync(resolvedConfigPath, cliffConfigPath);
+  }
   const outputFile = `${changelogPath}/CHANGELOG.md`;
   const args = ["--config", cliffConfigPath, "--output", outputFile, "--tag", tag];
   if (options?.tagPattern !== void 0) {
@@ -13,16 +23,22 @@ function generateChangelog(config, changelogPath, tag, dryRun, options) {
   for (const includePath of options?.includePaths ?? []) {
     args.push("--include-path", includePath);
   }
-  if (!dryRun) {
-    try {
-      execFileSync("npx", ["--yes", "git-cliff", ...args], { stdio: "inherit" });
-    } catch (error) {
-      throw new Error(
-        `Failed to generate changelog for ${outputFile}: ${error instanceof Error ? error.message : String(error)}`
-      );
+  try {
+    if (!dryRun) {
+      try {
+        execFileSync("npx", ["--yes", "git-cliff", ...args], { stdio: "inherit" });
+      } catch (error) {
+        throw new Error(
+          `Failed to generate changelog for ${outputFile}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return [outputFile];
+  } finally {
+    if (tempDir !== void 0) {
+      rmSync(tempDir, { recursive: true, force: true });
     }
   }
-  return [outputFile];
 }
 function generateChangelogs(config, tag, dryRun) {
   const tagPattern = buildTagPattern(config.tagPrefix);

package/dist/esm/githubReleaseCommand.d.ts

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

package/dist/esm/githubReleaseCommand.js

@@ -0,0 +1,35 @@
+import { parseArgs, translateParseError } from "@williamthorsen/node-monorepo-core";
+import { createGithubReleases } from "./createGithubRelease.js";
+import { resolveCommandTags } from "./resolveCommandTags.js";
+import { resolveReleaseNotesConfig } from "./resolveReleaseNotesConfig.js";
+const githubReleaseFlagSchema = {
+  dryRun: { long: "--dry-run", type: "boolean" },
+  only: { long: "--only", type: "string" }
+};
+async function githubReleaseCommand(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs(argv, githubReleaseFlagSchema);
+  } catch (error) {
+    console.error(`Error: ${translateParseError(error)}`);
+    process.exit(1);
+  }
+  const { dryRun } = parsed.flags;
+  const only = parsed.flags.only?.split(",");
+  const resolvedTags = await resolveCommandTags(only);
+  const { releaseNotes, changelogJsonOutputPath } = await resolveReleaseNotesConfig();
+  try {
+    createGithubReleases(
+      resolvedTags,
+      { ...releaseNotes, shouldCreateGithubRelease: true },
+      changelogJsonOutputPath,
+      dryRun
+    );
+  } catch (error) {
+    console.error(`Error creating GitHub Releases: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+export {
+  githubReleaseCommand
+};

package/dist/esm/index.d.ts

@@ -5,25 +5,33 @@ 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, Commit, ComponentConfig, ComponentOverride, ComponentPrepareResult, MonorepoReleaseConfig, ParsedCommit, PrepareResult, ReleaseConfig, ReleaseKitConfig, ReleaseType, VersionPatterns, WorkTypeConfig, } from './types.ts';
-export { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from './defaults.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 { publish } from './publish.ts';
+export { publishPackage } from './publish.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';

package/dist/esm/index.js

@@ -1,26 +1,39 @@
-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 { 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 { publish } from "./publish.js";
+import { publishPackage } from "./publish.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,
@@ -30,19 +43,30 @@ export {
   bumpVersion,
   commitCommand,
   component,
+  createGithubRelease,
+  createGithubReleases,
   createTags,
   deleteFileIfExists,
   detectPackageManager,
   determineBumpType,
   discoverWorkspaces,
   generateChangelog,
+  generateChangelogJson,
   generateChangelogs,
+  generateSyntheticChangelogJson,
   getCommitsSinceTarget,
+  injectReleaseNotesIntoReadme,
+  injectSection,
+  matchesAudience,
   parseCommitMessage,
-  publish,
+  publishPackage,
   releasePrepare,
   releasePrepareMono,
+  renderReleaseNotesMulti,
+  renderReleaseNotesSingle,
   reportPrepare,
+  resolveCommandTags,
+  resolveReadmePath,
   resolveReleaseTags,
   stripScope,
   writeReleaseTags

package/dist/esm/injectReleaseNotesIntoReadme.d.ts

@@ -0,0 +1,2 @@
+export declare function injectReleaseNotesIntoReadme(readmePath: string, changelogJsonPath: string, tag: string): string | undefined;
+export declare function resolveReadmePath(workspacePath: string): string | undefined;