@williamthorsen/release-kit 5.1.0 → 5.2.1

package/dist/esm/releasePrepare.js

@@ -2,8 +2,9 @@ import { execSync } from "node:child_process";
 import { buildChangelogEntries } from "./buildChangelogEntries.js";
 import { bumpAllVersions, setAllVersions } from "./bumpAllVersions.js";
 import { resolveChangelogJsonPath, upsertChangelogJson } from "./changelogJsonFile.js";
+import { createPolicyViolationCollector } from "./collectPolicyViolations.js";
 import { isForwardVersion } from "./compareVersions.js";
-import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
+import { DEFAULT_BREAKING_POLICIES, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { determineBumpFromCommits } from "./determineBumpFromCommits.js";
 import { generateChangelogs } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
@@ -16,10 +17,12 @@ function releasePrepare(config, options) {
   const { dryRun, bumpOverride, setVersion, withReleaseNotes } = options;
   const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
   const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
+  const breakingPolicies = config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES;
   const { tag, commits } = getCommitsSinceTarget([config.tagPrefix]);
   let releaseType;
   let parsedCommitCount;
   let unparseableCommits;
+  const collector = createPolicyViolationCollector();
   let bump;
   if (setVersion !== void 0) {
     const primaryPackageFile = config.packageFiles[0];
@@ -36,7 +39,10 @@ function releasePrepare(config, options) {
     bump = setAllVersions(config.packageFiles, setVersion, dryRun);
   } else {
     if (bumpOverride === void 0) {
-      const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.scopeAliases);
+      const determination = determineBumpFromCommits(commits, workTypes, versionPatterns, config.scopeAliases, {
+        breakingPolicies,
+        onPolicyViolation: collector.onPolicyViolation
+      });
       parsedCommitCount = determination.parsedCommitCount;
       unparseableCommits = determination.unparseableCommits;
       releaseType = determination.releaseType;
@@ -44,20 +50,13 @@ function releasePrepare(config, options) {
       releaseType = bumpOverride;
     }
     if (releaseType === void 0) {
-      const skipped = {
-        status: "skipped",
+      const skipped = buildSkippedSinglePackage({
         commitCount: commits.length,
-        skipReason: "No release-worthy changes found. Skipping."
-      };
-      if (tag !== void 0) {
-        skipped.previousTag = tag;
-      }
-      if (parsedCommitCount !== void 0) {
-        skipped.parsedCommitCount = parsedCommitCount;
-      }
-      if (unparseableCommits !== void 0) {
-        skipped.unparseableCommits = unparseableCommits;
-      }
+        previousTag: tag,
+        parsedCommitCount,
+        unparseableCommits,
+        policyViolations: collector.violations.length > 0 ? collector.violations : void 0
+      });
       return {
         workspaces: [skipped],
         tags: [],
@@ -100,6 +99,7 @@ function releasePrepare(config, options) {
     parsedCommitCount,
     releaseType,
     unparseableCommits,
+    policyViolations: collector.violations.length > 0 ? collector.violations : void 0,
     setVersion
   });
   return {
@@ -109,6 +109,26 @@ function releasePrepare(config, options) {
     dryRun
   };
 }
+function buildSkippedSinglePackage(args) {
+  const skipped = {
+    status: "skipped",
+    commitCount: args.commitCount,
+    skipReason: "No release-worthy changes found. Skipping."
+  };
+  if (args.previousTag !== void 0) {
+    skipped.previousTag = args.previousTag;
+  }
+  if (args.parsedCommitCount !== void 0) {
+    skipped.parsedCommitCount = args.parsedCommitCount;
+  }
+  if (args.unparseableCommits !== void 0) {
+    skipped.unparseableCommits = args.unparseableCommits;
+  }
+  if (args.policyViolations !== void 0) {
+    skipped.policyViolations = args.policyViolations;
+  }
+  return skipped;
+}
 function buildReleasedSinglePackage(args) {
   const {
     commits,
@@ -119,6 +139,7 @@ function buildReleasedSinglePackage(args) {
     parsedCommitCount,
     releaseType,
     unparseableCommits,
+    policyViolations,
     setVersion
   } = args;
   const released = {
@@ -143,6 +164,9 @@ function buildReleasedSinglePackage(args) {
   if (unparseableCommits !== void 0) {
     released.unparseableCommits = unparseableCommits;
   }
+  if (policyViolations !== void 0) {
+    released.policyViolations = policyViolations;
+  }
   if (setVersion !== void 0) {
     released.setVersion = setVersion;
   }

package/dist/esm/releasePrepareMono.js

@@ -4,9 +4,10 @@ import { buildDependencyGraph } from "./buildDependencyGraph.js";
 import { buildSyntheticChangelogEntry } from "./buildSyntheticChangelogEntry.js";
 import { bumpAllVersions, setAllVersions } from "./bumpAllVersions.js";
 import { resolveChangelogJsonPath, upsertChangelogJson } from "./changelogJsonFile.js";
+import { createPolicyViolationCollector } from "./collectPolicyViolations.js";
 import { isForwardVersion } from "./compareVersions.js";
 import { decideRelease } from "./decideRelease.js";
-import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
+import { DEFAULT_BREAKING_POLICIES, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { detectUndeclaredTagPrefixes } from "./detectUndeclaredTagPrefixes.js";
 import { buildTagPattern, generateChangelog } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
@@ -83,6 +84,7 @@ function determineDirectBumps(config, options) {
   }
   const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
   const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
+  const breakingPolicies = config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES;
   const directBumps = /* @__PURE__ */ new Map();
   const directResults = /* @__PURE__ */ new Map();
   const skippedResults = [];
@@ -125,11 +127,13 @@ function determineDirectBumps(config, options) {
         releaseType: void 0,
         parsedCommitCount: void 0,
         unparseableCommits: void 0,
+        policyViolations: void 0,
         bumpOverride: void 0,
         setVersion
       });
       continue;
     }
+    const collector = createPolicyViolationCollector();
     const decision = tryStage(
       stageLabel,
       () => decideRelease({
@@ -139,12 +143,15 @@ function determineDirectBumps(config, options) {
         workTypes,
         versionPatterns,
         scopeAliases: config.scopeAliases,
+        breakingPolicies,
+        onPolicyViolation: collector.onPolicyViolation,
         skipReasons: {
           noCommits: `No commits for ${name} ${since}. Pass --force to release at patch. Skipping.`,
           noBumpWorthy: `No bump-worthy commits for ${name} ${since}. Pass --force to release at patch (or --force --bump=X for a different level). Skipping.`
         }
       })
     );
+    const policyViolations = collector.violations.length > 0 ? collector.violations : void 0;
     if (decision.outcome === "skip") {
       skippedResults.push({
         workspace,
@@ -152,6 +159,7 @@ function determineDirectBumps(config, options) {
         commitCount: commits.length,
         parsedCommitCount: decision.parsedCommitCount,
         unparseableCommits: decision.unparseableCommits,
+        policyViolations,
         skipReason: decision.skipReason
       });
       continue;
@@ -164,6 +172,7 @@ function determineDirectBumps(config, options) {
       releaseType: decision.releaseType,
       parsedCommitCount: decision.parsedCommitCount,
       unparseableCommits: decision.unparseableCommits,
+      policyViolations,
       bumpOverride
     });
   }
@@ -190,6 +199,9 @@ function collectSkippedWorkspaces(skippedResults, fullReleaseSet) {
     if (skipped.unparseableCommits !== void 0) {
       result.unparseableCommits = skipped.unparseableCommits;
     }
+    if (skipped.policyViolations !== void 0) {
+      result.policyViolations = skipped.policyViolations;
+    }
     workspaces.push(result);
   }
   return workspaces;
@@ -270,7 +282,16 @@ function executeWorkspaceRelease(args) {
     bumpedFiles: bump.files,
     changelogFiles
   };
-  const previousTag = directResult?.tag ?? previousTags.get(dir);
+  attachReleasedWorkspaceOptionals(released, {
+    previousTag: directResult?.tag ?? previousTags.get(dir),
+    directResult,
+    releaseEntry,
+    setVersionTarget
+  });
+  workspaces.push(released);
+}
+function attachReleasedWorkspaceOptionals(released, args) {
+  const { previousTag, directResult, releaseEntry, setVersionTarget } = args;
   if (previousTag !== void 0) {
     released.previousTag = previousTag;
   }
@@ -286,6 +307,9 @@ function executeWorkspaceRelease(args) {
   if (directResult?.unparseableCommits !== void 0) {
     released.unparseableCommits = directResult.unparseableCommits;
   }
+  if (directResult?.policyViolations !== void 0) {
+    released.policyViolations = directResult.policyViolations;
+  }
   if (releaseEntry.propagatedFrom !== void 0) {
     released.propagatedFrom = releaseEntry.propagatedFrom;
   }
@@ -295,7 +319,6 @@ function executeWorkspaceRelease(args) {
   if (setVersionTarget !== void 0) {
     released.setVersion = setVersionTarget;
   }
-  workspaces.push(released);
 }
 function generateWorkspaceChangelogs(args) {
   const {

package/dist/esm/releasePrepareProject.js

@@ -1,8 +1,9 @@
 import { buildChangelogEntries } from "./buildChangelogEntries.js";
 import { bumpAllVersions } from "./bumpAllVersions.js";
 import { resolveChangelogJsonPath, writeChangelogJson } from "./changelogJsonFile.js";
+import { createPolicyViolationCollector } from "./collectPolicyViolations.js";
 import { decideRelease } from "./decideRelease.js";
-import { DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
+import { DEFAULT_BREAKING_POLICIES, DEFAULT_VERSION_PATTERNS, DEFAULT_WORK_TYPES } from "./defaults.js";
 import { buildTagPattern, generateChangelog } from "./generateChangelogs.js";
 import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
 import { deriveSectionOrder } from "./resolveReleaseNotesConfig.js";
@@ -18,9 +19,11 @@ function releasePrepareProject(args) {
   }
   const workTypes = config.workTypes ?? { ...DEFAULT_WORK_TYPES };
   const versionPatterns = config.versionPatterns ?? { ...DEFAULT_VERSION_PATTERNS };
+  const breakingPolicies = config.breakingPolicies ?? DEFAULT_BREAKING_POLICIES;
   const contributingPaths = config.workspaces.flatMap((workspace) => workspace.paths);
   const { tag, commits } = getCommitsSinceTarget([project.tagPrefix], contributingPaths);
   const since = tag === void 0 ? "(no previous release found)" : `since ${tag}`;
+  const collector = createPolicyViolationCollector();
   const decision = decideRelease({
     commits,
     force,
@@ -28,11 +31,14 @@ function releasePrepareProject(args) {
     workTypes,
     versionPatterns,
     scopeAliases: config.scopeAliases,
+    breakingPolicies,
+    onPolicyViolation: collector.onPolicyViolation,
     skipReasons: {
       noCommits: `No commits ${since}. Pass --force to release at patch. Skipping.`,
       noBumpWorthy: `No bump-worthy commits ${since}. Pass --force to release at patch (or --force --bump=X for a different level). Skipping.`
     }
   });
+  const policyViolations = collector.violations.length > 0 ? collector.violations : void 0;
   if (decision.outcome === "skip") {
     const skipped = {
       status: "skipped",
@@ -46,6 +52,9 @@ function releasePrepareProject(args) {
     if (decision.unparseableCommits !== void 0) {
       skipped.unparseableCommits = decision.unparseableCommits;
     }
+    if (policyViolations !== void 0) {
+      skipped.policyViolations = policyViolations;
+    }
     return skipped;
   }
   const { releaseType, parsedCommitCount, unparseableCommits } = decision;
@@ -99,6 +108,9 @@ function releasePrepareProject(args) {
   if (unparseableCommits !== void 0) {
     result.unparseableCommits = unparseableCommits;
   }
+  if (policyViolations !== void 0) {
+    result.policyViolations = policyViolations;
+  }
   if (bumpOverride !== void 0) {
     result.bumpOverride = bumpOverride;
   }

package/dist/esm/renderReleaseNotes.js

@@ -26,7 +26,8 @@ function renderReleaseNotesSingle(entry, options) {
     }
     lines.push(`### ${section.title}`, "");
     for (const [index, item] of section.items.entries()) {
-      lines.push(`- ${item.description}`);
+      const prefix = item.breaking === true ? "\u{1F6A8} **Breaking:** " : "";
+      lines.push(`- ${prefix}${item.description}`);
       if (item.body !== void 0 && item.body.length > 0) {
         lines.push("", ...indentBodyLines(item.body));
         if (index < section.items.length - 1) {

package/dist/esm/reportPrepare.js

@@ -18,6 +18,7 @@ function formatSingleWorkspace(result) {
     lines.push(dim(`  Parsed ${workspace.parsedCommitCount} typed commits`));
   }
   formatUnparseableWarning(lines, workspace);
+  formatPolicyViolations(lines, workspace.policyViolations);
   if (workspace.status === "skipped") {
     lines.push(`\u23ED\uFE0F  ${workspace.skipReason}`);
     return lines.join("\n");
@@ -71,6 +72,7 @@ function formatProjectSection(lines, project, dryRun) {
 ${sectionHeader("project")}`);
   const since = project.previousTag === void 0 ? "(no previous release found)" : `since ${project.previousTag}`;
   lines.push(dim(`  Found ${project.commitCount} commits ${since}`));
+  formatPolicyViolations(lines, project.policyViolations, "  ");
   if (project.status === "skipped") {
     lines.push(`  \u23ED\uFE0F  ${project.skipReason}`);
     return;
@@ -134,6 +136,7 @@ ${sectionHeader(workspace.name)}`);
   const isPropagatedOnly = propagatedFrom !== void 0 && workspace.commitCount === 0;
   formatCommitSummary(lines, workspace, propagatedFrom, isPropagatedOnly);
   formatUnparseableWarning(lines, workspace, "  ");
+  formatPolicyViolations(lines, workspace.policyViolations, "  ");
   formatBumpLabels(lines, workspace, isPropagatedOnly);
   formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly);
   formatBumpFiles(lines, workspace, dryRun, "  ");
@@ -202,6 +205,21 @@ function formatUnparseableWarning(lines, workspace, indent = "") {
     lines.push(`${indent}    \xB7 ${shortHash} ${truncatedMessage}`);
   }
 }
+function formatPolicyViolations(lines, violations, indent = "") {
+  if (violations === void 0 || violations.length === 0) {
+    return;
+  }
+  const count = violations.length;
+  lines.push(`${indent}  \u26A0\uFE0F  ${count} policy violation${count === 1 ? "" : "s"}:`);
+  for (const violation of violations) {
+    const shortHash = violation.commitHash.slice(0, 7);
+    const subject = violation.commitSubject;
+    const truncatedSubject = subject.length > 72 ? `${subject.slice(0, 69)}...` : subject;
+    lines.push(
+      `${indent}    \xB7 ${shortHash} '${truncatedSubject}' \u2014 type '${violation.type}' at ${violation.surface} surface`
+    );
+  }
+}
 function formatPropagationSuffix(propagatedFrom) {
   if (propagatedFrom === void 0 || propagatedFrom.length === 0) {
     return "";

package/dist/esm/resolveCommandTags.js

@@ -10,15 +10,25 @@ async function resolveCommandTags(tags) {
     process.exit(1);
   }
   let workspaces;
-  if (discoveredPaths !== void 0) {
-    try {
+  let singleWorkspace;
+  try {
+    if (discoveredPaths === void 0) {
+      singleWorkspace = deriveWorkspaceConfig(".");
+    } else {
       workspaces = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
-    } catch (error) {
-      console.error(`Error resolving workspaces: ${error instanceof Error ? error.message : String(error)}`);
-      process.exit(1);
     }
+  } catch (error) {
+    console.error(`Error resolving workspaces: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+  let resolvedTags;
+  if (workspaces !== void 0) {
+    resolvedTags = resolveReleaseTags({ workspaces });
+  } else if (singleWorkspace !== void 0) {
+    resolvedTags = resolveReleaseTags({ singleWorkspace });
+  } else {
+    throw new Error("resolveCommandTags: invariant violated \u2014 neither workspaces nor singleWorkspace was derived");
   }
-  let resolvedTags = resolveReleaseTags(workspaces);
   if (resolvedTags.length === 0) {
     console.error("Error: No release tags found on HEAD. Create tags with `release-kit tag` first.");
     process.exit(1);

package/dist/esm/resolveReleaseTags.d.ts

@@ -3,5 +3,12 @@ export interface ResolvedTag {
     tag: string;
     dir: string;
     workspacePath: string;
+    isPublishable: boolean;
 }
-export declare function resolveReleaseTags(workspaces?: readonly WorkspaceConfig[]): ResolvedTag[];
+type ResolveReleaseTagsArgs = {
+    workspaces: readonly WorkspaceConfig[];
+} | {
+    singleWorkspace: WorkspaceConfig;
+};
+export declare function resolveReleaseTags(args?: ResolveReleaseTagsArgs): ResolvedTag[];
+export {};

package/dist/esm/resolveReleaseTags.js

@@ -1,23 +1,27 @@
 import { execFileSync } from "node:child_process";
 const VERSION_PATTERN = /^v\d+\.\d+\.\d+/;
 const SEMVER_SUFFIX_PATTERN = /^\d+\.\d+\.\d+/;
-function resolveReleaseTags(workspaces) {
+function resolveReleaseTags(args) {
   const output = execFileSync("git", ["tag", "--points-at", "HEAD"], { encoding: "utf8" });
   const tags = output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-  if (workspaces === void 0) {
+  if (args === void 0) {
     return resolveSinglePackageTags(tags);
   }
-  return resolveMonorepoTags(tags, workspaces);
+  if ("workspaces" in args) {
+    return resolveMonorepoTags(tags, args.workspaces);
+  }
+  return resolveSinglePackageTags(tags, args.singleWorkspace);
 }
-function resolveSinglePackageTags(tags) {
+function resolveSinglePackageTags(tags, singleWorkspace) {
   const matched = tags.filter((tag) => VERSION_PATTERN.test(tag));
+  const isPublishable = singleWorkspace?.isPublishable ?? true;
   if (matched.length > 1) {
     console.warn(
       `Warning: Multiple version tags found on HEAD: ${matched.join(", ")}. Publishing the same package multiple times is almost certainly unintended. Using only the first tag.`
     );
-    return matched.slice(0, 1).map((tag) => ({ tag, dir: ".", workspacePath: "." }));
+    return matched.slice(0, 1).map((tag) => ({ tag, dir: ".", workspacePath: ".", isPublishable }));
   }
-  return matched.map((tag) => ({ tag, dir: ".", workspacePath: "." }));
+  return matched.map((tag) => ({ tag, dir: ".", workspacePath: ".", isPublishable }));
 }
 function resolveMonorepoTags(tags, workspaces) {
   const sortedWorkspaces = [...workspaces].sort((a, b) => b.tagPrefix.length - a.tagPrefix.length);
@@ -25,7 +29,7 @@ function resolveMonorepoTags(tags, workspaces) {
   for (const tag of tags) {
     const match = findMatchingWorkspace(tag, sortedWorkspaces);
     if (match !== void 0) {
-      resolved.push({ tag, dir: match.dir, workspacePath: match.workspacePath });
+      resolved.push({ tag, dir: match.dir, workspacePath: match.workspacePath, isPublishable: match.isPublishable });
     }
   }
   return resolved;

package/dist/esm/runGitCliff.d.ts

@@ -0,0 +1,2 @@
+import { type StdioOptions } from 'node:child_process';
+export declare function runGitCliff(cliffConfigPath: string, cliffArgs: readonly string[], stdio: StdioOptions): string;

package/dist/esm/runGitCliff.js

@@ -0,0 +1,27 @@
+import { execFileSync } from "node:child_process";
+import { copyFileSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function runGitCliff(cliffConfigPath, cliffArgs, stdio) {
+  let configPath = cliffConfigPath;
+  let tempDir;
+  try {
+    if (cliffConfigPath.endsWith(".template")) {
+      tempDir = mkdtempSync(join(tmpdir(), "cliff-"));
+      configPath = join(tempDir, "cliff.toml");
+      copyFileSync(cliffConfigPath, configPath);
+    }
+    return execFileSync("npx", ["--prefer-offline", "--yes", "git-cliff", "--config", configPath, ...cliffArgs], {
+      encoding: "utf8",
+      stdio,
+      env: { ...process.env, npm_config_progress: "false" }
+    });
+  } finally {
+    if (tempDir !== void 0) {
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  }
+}
+export {
+  runGitCliff
+};

package/dist/esm/stripEmojiPrefix.d.ts

@@ -0,0 +1 @@
+export declare function stripEmojiPrefix(value: string): string;

package/dist/esm/stripEmojiPrefix.js

@@ -0,0 +1,7 @@
+const LEADING_EMOJI = /^\p{Extended_Pictographic}️? /u;
+function stripEmojiPrefix(value) {
+  return value.replace(LEADING_EMOJI, "");
+}
+export {
+  stripEmojiPrefix
+};

package/dist/esm/syncWorkTypes.d.ts

@@ -0,0 +1,10 @@
+export interface SyncResult {
+    exitCode: 0 | 2 | 3;
+    message: string;
+}
+export interface SyncWorkTypesDependencies {
+    localPath?: string;
+    fetch?: typeof globalThis.fetch;
+    upstreamUrl?: string;
+}
+export declare function syncWorkTypes(dependencies?: SyncWorkTypesDependencies): Promise<SyncResult>;

package/dist/esm/syncWorkTypes.js

@@ -0,0 +1,90 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { UPSTREAM_WORK_TYPES_URL } from "./checkWorkTypesDrift.js";
+import { isRecord } from "./typeGuards.js";
+import { errorMessage, hasExpectedTopLevelShape } from "./workTypesUtils.js";
+function resolveDefaultLocalPath() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  return resolve(moduleDir, "work-types.json");
+}
+function extractLocalSchemaUrl(content) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) {
+    return void 0;
+  }
+  const schema = parsed.$schema;
+  return typeof schema === "string" ? schema : void 0;
+}
+async function syncWorkTypes(dependencies = {}) {
+  const localPath = dependencies.localPath ?? resolveDefaultLocalPath();
+  const fetcher = dependencies.fetch ?? globalThis.fetch;
+  const url = dependencies.upstreamUrl ?? UPSTREAM_WORK_TYPES_URL;
+  let response;
+  try {
+    response = await fetcher(url);
+  } catch (error) {
+    return {
+      exitCode: 2,
+      message: `Network error fetching upstream work-types.json: ${errorMessage(error)}`
+    };
+  }
+  if (!response.ok) {
+    return {
+      exitCode: 2,
+      message: `Failed to fetch upstream work-types.json: HTTP ${response.status} ${response.statusText}`
+    };
+  }
+  const upstreamText = await response.text();
+  let upstreamJson;
+  try {
+    upstreamJson = JSON.parse(upstreamText);
+  } catch (error) {
+    return {
+      exitCode: 3,
+      message: `Upstream work-types.json is not valid JSON: ${errorMessage(error)}`
+    };
+  }
+  if (!hasExpectedTopLevelShape(upstreamJson)) {
+    return {
+      exitCode: 3,
+      message: "Upstream work-types.json does not match the expected schema shape (missing `tiers` or `types`)."
+    };
+  }
+  let priorContent;
+  try {
+    priorContent = readFileSync(localPath, "utf8");
+  } catch {
+    priorContent = void 0;
+  }
+  const localSchemaUrl = priorContent !== void 0 ? extractLocalSchemaUrl(priorContent) : void 0;
+  const outputJson = localSchemaUrl !== void 0 ? { $schema: localSchemaUrl, ...upstreamJson } : upstreamJson;
+  const formatted = `${JSON.stringify(outputJson, null, 2)}
+`;
+  if (priorContent === formatted) {
+    return {
+      exitCode: 0,
+      message: `Local work-types.json already matches upstream (${localPath}).`
+    };
+  }
+  try {
+    writeFileSync(localPath, formatted, "utf8");
+  } catch (error) {
+    return {
+      exitCode: 2,
+      message: `Failed to write ${localPath}: ${errorMessage(error)}`
+    };
+  }
+  return {
+    exitCode: 0,
+    message: `Synced work-types.json from ${url} \u2192 ${localPath}.`
+  };
+}
+export {
+  syncWorkTypes
+};

package/dist/esm/types.d.ts

@@ -3,6 +3,7 @@ export type ChangelogAudience = 'all' | 'dev';
 export interface ChangelogItem {
     description: string;
     body?: string;
+    breaking?: boolean;
 }
 export interface ChangelogSection {
     title: string;
@@ -37,6 +38,12 @@ export interface BumpResult {
     newVersion: string;
     files: string[];
 }
+export interface PolicyViolation {
+    commitHash: string;
+    commitSubject: string;
+    type: string;
+    surface: 'prefix' | 'body';
+}
 export interface ReleasedWorkspaceResult {
     status: 'released';
     name?: string;
@@ -44,6 +51,7 @@ export interface ReleasedWorkspaceResult {
     commitCount: number;
     parsedCommitCount?: number;
     unparseableCommits?: Commit[];
+    policyViolations?: PolicyViolation[];
     releaseType?: ReleaseType;
     currentVersion: string;
     newVersion: string;
@@ -62,6 +70,7 @@ export interface SkippedWorkspaceResult {
     commitCount: number;
     parsedCommitCount?: number;
     unparseableCommits?: Commit[];
+    policyViolations?: PolicyViolation[];
     skipReason: string;
 }
 export type WorkspacePrepareResult = ReleasedWorkspaceResult | SkippedWorkspaceResult;
@@ -71,6 +80,7 @@ export interface ReleasedProjectResult {
     commitCount: number;
     parsedCommitCount: number;
     unparseableCommits?: Commit[];
+    policyViolations?: PolicyViolation[];
     releaseType: ReleaseType;
     currentVersion: string;
     newVersion: string;
@@ -86,6 +96,7 @@ export interface SkippedProjectResult {
     commitCount: number;
     parsedCommitCount: number;
     unparseableCommits?: Commit[];
+    policyViolations?: PolicyViolation[];
     skipReason: string;
 }
 export type ProjectPrepareResult = ReleasedProjectResult | SkippedProjectResult;
@@ -113,6 +124,7 @@ export interface ReleaseKitConfig {
     workspaces?: WorkspaceOverride[];
     versionPatterns?: VersionPatterns;
     workTypes?: Record<string, WorkTypeConfig>;
+    breakingPolicies?: Record<string, 'forbidden' | 'optional' | 'required'>;
     formatCommand?: string;
     cliffConfigPath?: string;
     scopeAliases?: Record<string, string>;
@@ -152,6 +164,7 @@ export interface WorkspaceConfig {
     name: string;
     tagPrefix: string;
     workspacePath: string;
+    isPublishable: boolean;
     packageFiles: string[];
     changelogPaths: string[];
     paths: string[];
@@ -161,6 +174,7 @@ export interface MonorepoReleaseConfig {
     workspaces: WorkspaceConfig[];
     workTypes?: Record<string, WorkTypeConfig>;
     versionPatterns?: VersionPatterns;
+    breakingPolicies?: Record<string, 'forbidden' | 'optional' | 'required'>;
     formatCommand?: string;
     cliffConfigPath?: string;
     scopeAliases?: Record<string, string>;
@@ -174,6 +188,7 @@ export interface ReleaseConfig {
     changelogPaths: string[];
     workTypes?: Record<string, WorkTypeConfig>;
     versionPatterns?: VersionPatterns;
+    breakingPolicies?: Record<string, 'forbidden' | 'optional' | 'required'>;
     formatCommand?: string;
     cliffConfigPath?: string;
     scopeAliases?: Record<string, string>;