@williamthorsen/release-kit 5.1.0 → 5.2.0

package/dist/esm/checkWorkTypesDrift.d.ts

@@ -0,0 +1,11 @@
+export declare const UPSTREAM_WORK_TYPES_URL = "https://raw.githubusercontent.com/williamthorsen/codeassembly/main/packages/agents/content/skills/_data/work-types.json";
+export interface DriftCheckResult {
+    exitCode: 0 | 1 | 2 | 3;
+    message: string;
+}
+export interface CheckWorkTypesDriftDependencies {
+    localPath?: string;
+    fetch?: typeof globalThis.fetch;
+    upstreamUrl?: string;
+}
+export declare function checkWorkTypesDrift(dependencies?: CheckWorkTypesDriftDependencies): Promise<DriftCheckResult>;

package/dist/esm/checkWorkTypesDrift.js

@@ -0,0 +1,110 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { errorMessage, hasExpectedTopLevelShape } from "./workTypesUtils.js";
+const UPSTREAM_WORK_TYPES_URL = "https://raw.githubusercontent.com/williamthorsen/codeassembly/main/packages/agents/content/skills/_data/work-types.json";
+function resolveDefaultLocalPath() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  return resolve(moduleDir, "work-types.json");
+}
+async function checkWorkTypesDrift(dependencies = {}) {
+  const localPath = dependencies.localPath ?? resolveDefaultLocalPath();
+  const fetcher = dependencies.fetch ?? globalThis.fetch;
+  const url = dependencies.upstreamUrl ?? UPSTREAM_WORK_TYPES_URL;
+  const localContent = readFileSync(localPath, "utf8");
+  let localJson;
+  try {
+    localJson = JSON.parse(localContent);
+  } catch (error) {
+    return {
+      exitCode: 3,
+      message: `Local work-types.json is not valid JSON: ${errorMessage(error)}`
+    };
+  }
+  let response;
+  try {
+    response = await fetcher(url);
+  } catch (error) {
+    return {
+      exitCode: 2,
+      message: `Network error fetching upstream work-types.json: ${errorMessage(error)}`
+    };
+  }
+  if (response.status === 404) {
+    return {
+      exitCode: 0,
+      message: `Upstream work-types.json not yet published at ${url}; skipping drift check.`
+    };
+  }
+  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`)."
+    };
+  }
+  const normalisedLocal = stripLocalOnlyFields(localJson);
+  if (deepEqual(normalisedLocal, upstreamJson)) {
+    return {
+      exitCode: 0,
+      message: "Local work-types.json matches upstream."
+    };
+  }
+  return {
+    exitCode: 1,
+    message: `Drift detected. Local and upstream work-types.json differ. Run \`nmr work-types:sync\` to update from upstream.
+Local:    ${localPath}
+Upstream: ${url}`
+  };
+}
+function stripLocalOnlyFields(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return value;
+  }
+  const record = { ...value };
+  delete record.$schema;
+  return record;
+}
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return a === b;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEqual(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  if (typeof a === "object" && typeof b === "object" && !Array.isArray(a) && !Array.isArray(b)) {
+    const aRecord = { ...a };
+    const bRecord = { ...b };
+    const aKeys = Object.keys(aRecord);
+    const bKeys = Object.keys(bRecord);
+    if (aKeys.length !== bKeys.length) return false;
+    for (const key of aKeys) {
+      if (!deepEqual(aRecord[key], bRecord[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+export {
+  UPSTREAM_WORK_TYPES_URL,
+  checkWorkTypesDrift
+};

package/dist/esm/collectPolicyViolations.d.ts

@@ -0,0 +1,6 @@
+import type { PolicyViolationHandler } from './parseCommitMessage.ts';
+import type { PolicyViolation } from './types.ts';
+export declare function createPolicyViolationCollector(): {
+    violations: PolicyViolation[];
+    onPolicyViolation: PolicyViolationHandler;
+};

package/dist/esm/collectPolicyViolations.js

@@ -0,0 +1,15 @@
+function createPolicyViolationCollector() {
+  const violations = [];
+  const onPolicyViolation = (commit, type, surface) => {
+    violations.push({
+      commitHash: commit.hash,
+      commitSubject: commit.message.split("\n", 1)[0] ?? "",
+      type,
+      surface
+    });
+  };
+  return { violations, onPolicyViolation };
+}
+export {
+  createPolicyViolationCollector
+};

package/dist/esm/createGithubRelease.d.ts

@@ -4,10 +4,20 @@ export interface CreateGithubReleaseOptions {
     dryRun: boolean;
     sectionOrder?: string[];
 }
-export declare function createGithubRelease(options: CreateGithubReleaseOptions): boolean;
+export type CreateReleaseSkipReason = 'no-entry' | 'no-audience-content' | 'empty-body';
+export type CreateReleaseResult = {
+    status: 'created';
+} | {
+    status: 'skipped';
+    reason: CreateReleaseSkipReason;
+};
+export declare function createGithubRelease(options: CreateGithubReleaseOptions): CreateReleaseResult;
 export interface CreateGithubReleasesOutcome {
     created: string[];
-    skipped: string[];
+    skipped: Array<{
+        tag: string;
+        reason: CreateReleaseSkipReason;
+    }>;
 }
 export declare function createGithubReleases(tags: Array<{
     tag: string;

package/dist/esm/createGithubRelease.js

@@ -7,21 +7,21 @@ function createGithubRelease(options) {
   const { tag, changelogJsonPath, dryRun, sectionOrder } = options;
   if (!existsSync(changelogJsonPath)) {
     console.warn(`Warning: ${changelogJsonPath} not found; skipping GitHub Release creation`);
-    return false;
+    return { status: "skipped", reason: "no-entry" };
   }
   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;
+    return { status: "skipped", reason: "no-entry" };
   }
   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;
+    return { status: "skipped", reason: "no-entry" };
   }
   if (!entry.sections.some(matchesAudience("all"))) {
-    return false;
+    return { status: "skipped", reason: "no-audience-content" };
   }
   const body = renderReleaseNotesSingle(entry, {
     filter: matchesAudience("all"),
@@ -29,15 +29,15 @@ function createGithubRelease(options) {
     ...sectionOrder === void 0 ? {} : { sectionOrder }
   });
   if (body.trim() === "") {
-    return false;
+    return { status: "skipped", reason: "empty-body" };
   }
   const args = ["release", "create", tag, "--title", tag, "--notes", body];
   if (dryRun) {
     console.info(`[dry-run] Would run: gh ${args.join(" ")}`);
-    return true;
+    return { status: "created" };
   }
   execFileSync("gh", args, { stdio: "inherit" });
-  return true;
+  return { status: "created" };
 }
 function createGithubReleases(tags, changelogJsonOutputPath, dryRun, sectionOrder) {
   const created = [];
@@ -50,7 +50,11 @@ function createGithubReleases(tags, changelogJsonOutputPath, dryRun, sectionOrde
       dryRun,
       ...sectionOrder === void 0 ? {} : { sectionOrder }
     });
-    (result ? created : skipped).push(tag);
+    if (result.status === "created") {
+      created.push(tag);
+    } else {
+      skipped.push({ tag, reason: result.reason });
+    }
   }
   return { created, skipped };
 }

package/dist/esm/createGithubReleaseCommand.js

@@ -26,14 +26,18 @@ async function createGithubReleaseCommand(argv) {
     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 (requestedTags !== void 0) {
+    const noEntryTags = outcome.skipped.filter((s) => s.reason === "no-entry").map((s) => s.tag);
+    if (noEntryTags.length > 0) {
+      console.error(
+        `Error: requested tags have no changelog entry: ${noEntryTags.join(", ")}. Verify the tag names match a published changelog version.`
+      );
+      process.exit(1);
+    }
   }
   if (outcome.skipped.length > 0) {
-    console.info(`Skipped ${outcome.skipped.length} tag(s) with no releasable content: ${outcome.skipped.join(", ")}.`);
+    const formatted = outcome.skipped.map((s) => `${s.tag} (${s.reason})`).join(", ");
+    console.info(`Skipped ${outcome.skipped.length} tag(s) with no releasable content: ${formatted}.`);
   }
 }
 export {

package/dist/esm/decideRelease.d.ts

@@ -1,3 +1,4 @@
+import { type PolicyViolationHandler } from './parseCommitMessage.ts';
 import type { Commit, ReleaseType, VersionPatterns, WorkTypeConfig } from './types.ts';
 export interface DecideReleaseArgs {
     commits: readonly Commit[];
@@ -6,6 +7,8 @@ export interface DecideReleaseArgs {
     workTypes: Record<string, WorkTypeConfig>;
     versionPatterns: VersionPatterns;
     scopeAliases: Record<string, string> | undefined;
+    breakingPolicies?: Record<string, 'forbidden' | 'optional' | 'required'>;
+    onPolicyViolation?: PolicyViolationHandler;
     skipReasons: {
         noCommits: string;
         noBumpWorthy: string;

package/dist/esm/decideRelease.js

@@ -1,11 +1,27 @@
 import { determineBumpType } from "./determineBumpType.js";
-import { parseCommitMessage } from "./parseCommitMessage.js";
+import {
+  parseCommitMessage
+} from "./parseCommitMessage.js";
 function decideRelease(args) {
-  const { commits, force = false, bumpOverride, workTypes, versionPatterns, scopeAliases, skipReasons } = args;
+  const {
+    commits,
+    force = false,
+    bumpOverride,
+    workTypes,
+    versionPatterns,
+    scopeAliases,
+    breakingPolicies,
+    onPolicyViolation,
+    skipReasons
+  } = args;
+  const parseOptions = {
+    ...breakingPolicies !== void 0 && { breakingPolicies },
+    ...onPolicyViolation !== void 0 && { onPolicyViolation }
+  };
   const parsedCommits = [];
   const unparseable = [];
   for (const commit of commits) {
-    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, scopeAliases);
+    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, scopeAliases, parseOptions);
     if (parsed === void 0) {
       unparseable.push(commit);
     } else {

package/dist/esm/defaults.d.ts

@@ -1,5 +1,12 @@
 import type { ChangelogJsonConfig, ReleaseNotesConfig, VersionPatterns, WorkTypeConfig } from './types.ts';
+export type { WorkTypesData } from './workTypesData.ts';
+export { WORK_TYPES_DATA } from './workTypesData.ts';
+export declare function composeHeader(entry: {
+    emoji: string;
+    label: string;
+}): string;
 export declare const DEFAULT_WORK_TYPES: Record<string, WorkTypeConfig>;
+export declare const DEFAULT_BREAKING_POLICIES: Record<string, 'forbidden' | 'optional' | 'required'>;
 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,21 +1,39 @@
-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" },
-  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" }
-};
+import { WORK_TYPES_DATA } from "./workTypesData.js";
+import { WORK_TYPES_DATA as WORK_TYPES_DATA2 } from "./workTypesData.js";
+function composeHeader(entry) {
+  return `${entry.emoji} ${entry.label}`;
+}
+const DEV_ONLY_TIERS = /* @__PURE__ */ new Set(["Internal", "Process"]);
+function deriveDefaultWorkTypes() {
+  const result = {};
+  for (const entry of WORK_TYPES_DATA.types) {
+    const config = {
+      header: composeHeader(entry)
+    };
+    if (entry.aliases.length > 0) {
+      config.aliases = [...entry.aliases];
+    }
+    result[entry.key] = config;
+  }
+  return result;
+}
+function deriveDevOnlySections() {
+  const sections = [];
+  for (const entry of WORK_TYPES_DATA.types) {
+    if (!DEV_ONLY_TIERS.has(entry.tier)) {
+      continue;
+    }
+    if (entry.excludedFromChangelog === true) {
+      continue;
+    }
+    sections.push(composeHeader(entry));
+  }
+  return sections;
+}
+const DEFAULT_WORK_TYPES = deriveDefaultWorkTypes();
+const DEFAULT_BREAKING_POLICIES = Object.fromEntries(
+  WORK_TYPES_DATA.types.map((entry) => [entry.key, entry.breakingPolicy])
+);
 const DEFAULT_VERSION_PATTERNS = {
   major: ["!"],
   minor: ["feat"]
@@ -23,16 +41,19 @@ const DEFAULT_VERSION_PATTERNS = {
 const DEFAULT_CHANGELOG_JSON_CONFIG = {
   enabled: true,
   outputPath: ".meta/changelog.json",
-  devOnlySections: ["Agentic support", "CI", "Dependencies", "Internal", "Refactoring", "Tests", "Tooling"]
+  devOnlySections: deriveDevOnlySections()
 };
 const DEFAULT_RELEASE_NOTES_CONFIG = {
   shouldInjectIntoReadme: false
 };
 const DEFAULT_PROJECT_TAG_PREFIX = "v";
 export {
+  DEFAULT_BREAKING_POLICIES,
   DEFAULT_CHANGELOG_JSON_CONFIG,
   DEFAULT_PROJECT_TAG_PREFIX,
   DEFAULT_RELEASE_NOTES_CONFIG,
   DEFAULT_VERSION_PATTERNS,
-  DEFAULT_WORK_TYPES
+  DEFAULT_WORK_TYPES,
+  WORK_TYPES_DATA2 as WORK_TYPES_DATA,
+  composeHeader
 };

package/dist/esm/deriveWorkspaceConfig.js

@@ -16,11 +16,14 @@ function deriveWorkspaceConfig(workspacePath) {
     throw new Error(`${packageJsonPath} is missing a 'name' field (required for tag derivation).`);
   }
   const unscopedName = stripNpmScope(name);
+  const privateField = isRecord(parsed) ? parsed.private : void 0;
+  const isPublishable = privateField === void 0 || privateField === false;
   return {
     dir,
     name,
     tagPrefix: `${unscopedName}-v`,
     workspacePath,
+    isPublishable,
     packageFiles: [packageJsonPath],
     changelogPaths: [workspacePath],
     paths: [`${workspacePath}/**`]

package/dist/esm/determineBumpFromCommits.d.ts

@@ -1,7 +1,12 @@
+import { type PolicyViolationHandler } from './parseCommitMessage.ts';
 import type { Commit, ReleaseType, VersionPatterns, WorkTypeConfig } from './types.ts';
 export interface BumpDetermination {
     releaseType: ReleaseType | undefined;
     parsedCommitCount: number;
     unparseableCommits: Commit[] | undefined;
 }
-export declare function determineBumpFromCommits(commits: Commit[], workTypes: Record<string, WorkTypeConfig>, versionPatterns: VersionPatterns, scopeAliases: Record<string, string> | undefined): BumpDetermination;
+export interface DetermineBumpOptions {
+    breakingPolicies?: Record<string, 'forbidden' | 'optional' | 'required'>;
+    onPolicyViolation?: PolicyViolationHandler;
+}
+export declare function determineBumpFromCommits(commits: Commit[], workTypes: Record<string, WorkTypeConfig>, versionPatterns: VersionPatterns, scopeAliases: Record<string, string> | undefined, options?: DetermineBumpOptions): BumpDetermination;

package/dist/esm/determineBumpFromCommits.js

@@ -1,10 +1,16 @@
 import { determineBumpType } from "./determineBumpType.js";
-import { parseCommitMessage } from "./parseCommitMessage.js";
-function determineBumpFromCommits(commits, workTypes, versionPatterns, scopeAliases) {
+import {
+  parseCommitMessage
+} from "./parseCommitMessage.js";
+function determineBumpFromCommits(commits, workTypes, versionPatterns, scopeAliases, options) {
+  const parseOptions = {
+    ...options?.breakingPolicies !== void 0 && { breakingPolicies: options.breakingPolicies },
+    ...options?.onPolicyViolation !== void 0 && { onPolicyViolation: options.onPolicyViolation }
+  };
   const parsedCommits = [];
   const unparseable = [];
   for (const commit of commits) {
-    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, scopeAliases);
+    const parsed = parseCommitMessage(commit.message, commit.hash, workTypes, scopeAliases, parseOptions);
     if (parsed === void 0) {
       unparseable.push(commit);
     } else {

package/dist/esm/generateChangelogs.js

@@ -1,8 +1,5 @@
-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";
+import { runGitCliff } from "./runGitCliff.js";
 function buildTagPattern(tagPrefixes) {
   if (tagPrefixes.length === 0) {
     throw new Error("buildTagPattern: tagPrefixes must contain at least one entry");
@@ -18,38 +15,26 @@ function escapeRegex(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
 }
 function generateChangelog(config, changelogPath, tag, dryRun, options) {
-  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 (dryRun) {
+    return [outputFile];
+  }
+  const resolvedConfigPath = resolveCliffConfigPath(config.cliffConfigPath, import.meta.url);
+  const cliffArgs = ["--output", outputFile, "--tag", tag];
   if (options?.tagPattern !== void 0) {
-    args.push("--tag-pattern", options.tagPattern);
+    cliffArgs.push("--tag-pattern", options.tagPattern);
   }
   for (const includePath of options?.includePaths ?? []) {
-    args.push("--include-path", includePath);
+    cliffArgs.push("--include-path", includePath);
   }
   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 });
-    }
+    runGitCliff(resolvedConfigPath, cliffArgs, "inherit");
+  } catch (error) {
+    throw new Error(
+      `Failed to generate changelog for ${outputFile}: ${error instanceof Error ? error.message : String(error)}`
+    );
   }
+  return [outputFile];
 }
 function generateChangelogs(config, tag, dryRun) {
   const tagPattern = buildTagPattern([config.tagPrefix]);

package/dist/esm/loadConfig.js

@@ -92,19 +92,22 @@ function mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage) {
   if (project !== void 0) {
     result.project = project;
   }
-  const formatCommand = userConfig?.formatCommand;
-  if (formatCommand !== void 0) {
-    result.formatCommand = formatCommand;
+  applyOptionalPassthroughFields(result, userConfig);
+  return result;
+}
+function applyOptionalPassthroughFields(result, userConfig) {
+  if (userConfig?.formatCommand !== void 0) {
+    result.formatCommand = userConfig.formatCommand;
   }
-  const cliffConfigPath = userConfig?.cliffConfigPath;
-  if (cliffConfigPath !== void 0) {
-    result.cliffConfigPath = cliffConfigPath;
+  if (userConfig?.cliffConfigPath !== void 0) {
+    result.cliffConfigPath = userConfig.cliffConfigPath;
   }
-  const scopeAliases = userConfig?.scopeAliases;
-  if (scopeAliases !== void 0) {
-    result.scopeAliases = scopeAliases;
+  if (userConfig?.scopeAliases !== void 0) {
+    result.scopeAliases = userConfig.scopeAliases;
+  }
+  if (userConfig?.breakingPolicies !== void 0) {
+    result.breakingPolicies = userConfig.breakingPolicies;
   }
-  return result;
 }
 function mergeSinglePackageConfig(userConfig) {
   if (userConfig?.project !== void 0) {
@@ -123,18 +126,7 @@ function mergeSinglePackageConfig(userConfig) {
     changelogJson,
     releaseNotes
   };
-  const formatCommand = userConfig?.formatCommand;
-  if (formatCommand !== void 0) {
-    result.formatCommand = formatCommand;
-  }
-  const cliffConfigPath = userConfig?.cliffConfigPath;
-  if (cliffConfigPath !== void 0) {
-    result.cliffConfigPath = cliffConfigPath;
-  }
-  const scopeAliases = userConfig?.scopeAliases;
-  if (scopeAliases !== void 0) {
-    result.scopeAliases = scopeAliases;
-  }
+  applyOptionalPassthroughFields(result, userConfig);
   return result;
 }
 function resolveWorkTypes(userWorkTypes) {

package/dist/esm/parseCommitMessage.d.ts

@@ -1,3 +1,9 @@
-import type { ParsedCommit, WorkTypeConfig } from './types.ts';
+import type { Commit, ParsedCommit, WorkTypeConfig } from './types.ts';
 export declare const COMMIT_PREPROCESSOR_PATTERNS: readonly RegExp[];
-export declare function parseCommitMessage(message: string, hash: string, workTypes: Record<string, WorkTypeConfig>, scopeAliases?: Record<string, string>): ParsedCommit | undefined;
+export type PolicyViolationSurface = 'prefix' | 'body';
+export type PolicyViolationHandler = (commit: Commit, type: string, surface: PolicyViolationSurface) => void;
+export interface ParseCommitMessageOptions {
+    breakingPolicies?: Record<string, 'forbidden' | 'optional' | 'required'>;
+    onPolicyViolation?: PolicyViolationHandler;
+}
+export declare function parseCommitMessage(message: string, hash: string, workTypes: Record<string, WorkTypeConfig>, scopeAliases?: Record<string, string>, options?: ParseCommitMessageOptions): ParsedCommit | undefined;

package/dist/esm/parseCommitMessage.js

@@ -1,6 +1,7 @@
 const COMMIT_PREPROCESSOR_PATTERNS = [/^##\s+/, /^#\d+([.-]\d+)?\s+/, /^[A-Z]+-\d+\s+/];
-function parseCommitMessage(message, hash, workTypes, scopeAliases) {
-  const stripped = stripTicketPrefix(message);
+function parseCommitMessage(message, hash, workTypes, scopeAliases, options) {
+  const firstLine = message.split("\n", 1)[0] ?? "";
+  const stripped = stripTicketPrefix(firstLine);
   const match = stripped.match(/^(?:([^|]+)\|)?(\w+)(?:\(([^)]+)\))?(!)?:\s*(.*)$/);
   if (!match) {
     return void 0;
@@ -17,7 +18,15 @@ function parseCommitMessage(message, hash, workTypes, scopeAliases) {
   if (resolvedType === void 0) {
     return void 0;
   }
-  const breaking = breakingMarker === "!" || message.includes("BREAKING CHANGE:");
+  const commit = { message, hash };
+  const breaking = evaluateBreakingPolicy({
+    commit,
+    resolvedType,
+    hasPrefixBreaking: breakingMarker === "!",
+    hasFooterBreaking: message.includes("BREAKING CHANGE:"),
+    policy: options?.breakingPolicies?.[resolvedType] ?? "optional",
+    onPolicyViolation: options?.onPolicyViolation
+  });
   const rawScope = pipeScope ?? parenthesizedScope;
   const resolvedScope = rawScope !== void 0 && scopeAliases !== void 0 ? scopeAliases[rawScope] ?? rawScope : rawScope;
   return {
@@ -29,6 +38,26 @@ function parseCommitMessage(message, hash, workTypes, scopeAliases) {
     ...resolvedScope !== void 0 && { scope: resolvedScope }
   };
 }
+function evaluateBreakingPolicy(inputs) {
+  const { commit, resolvedType, hasPrefixBreaking, hasFooterBreaking, policy, onPolicyViolation } = inputs;
+  if (policy === "forbidden") {
+    if (hasPrefixBreaking) {
+      onPolicyViolation?.(commit, resolvedType, "prefix");
+    }
+    if (hasFooterBreaking) {
+      onPolicyViolation?.(commit, resolvedType, "body");
+    }
+    return false;
+  }
+  if (policy === "required") {
+    if (!hasPrefixBreaking) {
+      onPolicyViolation?.(commit, resolvedType, "prefix");
+      return false;
+    }
+    return true;
+  }
+  return hasPrefixBreaking || hasFooterBreaking;
+}
 function resolveType(rawType, workTypes) {
   const lowered = rawType.toLowerCase();
   for (const [key, config] of Object.entries(workTypes)) {