relizy 1.8.0 → 1.10.0

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 import { LogLevel } from '@maz-ui/node';
 import { LanguageModel, CallSettings } from 'ai';
-import { RawGitCommit, GitCommit, ChangelogConfig as ChangelogConfig$1, SemverBumpType } from 'changelogen';
+import { GitCommit, RawGitCommit, ChangelogConfig as ChangelogConfig$1, SemverBumpType, Reference as Reference$1 } from 'changelogen';
 import { ReleaseType } from 'semver';
 import { DeepPartial } from '@maz-ui/utils/ts-helpers/DeepPartial';
 import * as _slack_web_api from '@slack/web-api';
@@ -53,6 +53,7 @@ declare function getDefaultConfig(): {
     };
     scopeMap: {};
     release: Required<ReleaseConfig>;
+    commitlint: Required<Omit<CommitlintConfig, "helpUrl">> & Pick<CommitlintConfig, "helpUrl">;
     social: {
         twitter: {
             enabled: false;
@@ -62,7 +63,7 @@ declare function getDefaultConfig(): {
         slack: {
             enabled: boolean;
             onlyStable: boolean;
-            postMaxLength: number;
+            changelogFormat: string;
             noAuthors: boolean;
             noPackages: boolean;
         };
@@ -137,6 +138,319 @@ declare function writeChangelogToFile({ cwd, pkg, changelog, dryRun, }: {
     dryRun: boolean;
 }): void;
 
+/**
+ * Title of the changelog section of a commit type, `undefined` when the commits
+ * of this type never appear in the changelog.
+ */
+declare function getChangelogTitle(type: string, config: ResolvedRelizyConfig): string | undefined;
+/**
+ * The commit as written in the CHANGELOG.md files by relizy: a section with the
+ * commit and its body. `undefined` when the commit does not appear in the changelog.
+ */
+declare function renderChangelogEntry(commit: GitCommit, config: ResolvedRelizyConfig): string | undefined;
+/**
+ * Checks a changelog entry the way the release would: returns the problems that
+ * would make the formatting of the CHANGELOG.md files fail.
+ */
+interface ChangelogLinter {
+    name: 'eslint' | 'oxc';
+    lint: (markdown: string) => Promise<string[]>;
+}
+/**
+ * The linter of the changelog entries of a project: its ESLint when it lints the
+ * CHANGELOG.md files, otherwise a syntax check of the code blocks. Loaded once per cwd.
+ */
+declare function getChangelogLinter(cwd: string): Promise<ChangelogLinter>;
+
+/** Character git uses for the comment lines of the edited messages */
+declare function getCommentChar(cwd: string): string;
+/**
+ * Path of the message of the commit being created: the file given to the
+ * `commit-msg` hook, `.git/COMMIT_EDITMSG` by default.
+ */
+declare function getCommitMessageFile(file: string | undefined, cwd: string): string;
+/** The message of the commit being created */
+declare function readCommitMessageFile(file: string | undefined, cwd: string): string;
+/** Files staged for the commit being created, relative to the repository root */
+declare function getStagedFiles(cwd: string): string[];
+interface RangeCommit {
+    hash: string;
+    message: string;
+    files: string[];
+}
+/**
+ * Commits reachable from `to` and not from `from`, oldest first, with their
+ * full message and changed files. Every commit up to `to` without `from`.
+ */
+declare function getCommitsInRange({ from, to, cwd }: {
+    from?: string;
+    to?: string;
+    cwd: string;
+}): RangeCommit[];
+/**
+ * Throws a helpful error when the start of the range is not in the local
+ * history, e.g. in a shallow clone of the CI.
+ */
+declare function assertRefAvailable(ref: string, cwd: string): void;
+interface PullRequestTitle {
+    title: string;
+    /** `pull request` on GitHub, `merge request` on GitLab */
+    kind: 'pull request' | 'merge request';
+}
+/**
+ * Title of the pull/merge request of the CI run, which becomes the commit
+ * message of a squash merge. The draft markers of GitLab are removed.
+ */
+declare function getPullRequestTitle(): PullRequestTitle | undefined;
+interface DefaultRangeStart {
+    from?: string;
+    /** Why this start was chosen, for the logs */
+    reason: string;
+}
+/**
+ * Start of the commits to lint when `--from` is not given: the merge-base with
+ * the target branch of the pull/merge request in GitHub Actions and GitLab CI,
+ * otherwise the last tag, otherwise the whole history.
+ */
+declare function resolveDefaultRangeStart({ cwd, logLevel }: {
+    cwd: string;
+    logLevel?: LogLevel;
+}): Promise<DefaultRangeStart>;
+interface InstalledHook {
+    path: string;
+    status: 'created' | 'replaced' | 'unchanged';
+}
+/**
+ * Write the `commit-msg` hook running `relizy commitlint`: in `.husky/` when
+ * husky is set up, otherwise in the hooks directory of git. An existing hook is
+ * only replaced with `force`.
+ */
+declare function installCommitMsgHook({ cwd, force }: {
+    cwd: string;
+    force?: boolean;
+}): InstalledHook;
+
+/**
+ * A commit message split into its parts, before any conventional parsing.
+ */
+interface CommitMessageParts {
+    /** Full message, comments removed, trailing blank lines trimmed */
+    raw: string;
+    header: string;
+    body: string;
+    footer: string;
+    /** Whether a blank line separates the header from the rest of the message */
+    hasLeadingBlank: boolean;
+}
+/**
+ * Remove what git strips from a message edited in the editor: the comment lines
+ * and everything after the scissors line of `git commit --verbose`.
+ */
+declare function stripGitComments(message: string, commentChar?: string): string;
+/**
+ * Split a message into header, body and footer. The footer is the last
+ * paragraph when it starts with a `Token: value` line: as in Conventional
+ * Commits, a footer value can continue on the next lines.
+ */
+declare function splitCommitMessage(message: string): CommitMessageParts;
+/**
+ * Whether a message must not be linted: merge commits, autosquash commits and
+ * the release commits of relizy (`defaultIgnores`), and the `ignores` of the config.
+ */
+declare function isIgnoredCommitMessage(message: string, config: ResolvedRelizyConfig): boolean;
+
+/**
+ * A workspace package as seen by the commit linter.
+ */
+interface WorkspacePackage {
+    /** Name from the package.json, e.g. `@maz-ui/nuxt` */
+    name: string;
+    /** Path relative to the repository root, POSIX separators, e.g. `packages/nuxt` */
+    path: string;
+    /** Scopes designating the package: short name, full name and folder name */
+    scopes: string[];
+}
+/**
+ * Packages of the monorepo, private ones included: a commit can touch a package
+ * that is never published. `commitlint.packages` adds directories that relizy
+ * does not release (e.g. apps). `monorepo.ignored` is not applied: an ignored
+ * package is released by another config, it is still a valid scope.
+ * Empty in standalone mode without them.
+ */
+declare function getWorkspacePackages(config: ResolvedRelizyConfig): WorkspacePackage[];
+/**
+ * Scopes allowed by the config: the workspace packages, the `scopeMap` keys and
+ * `commitlint.scopes`. `undefined` when any scope is allowed (standalone mode
+ * without an explicit list).
+ */
+declare function getAllowedScopes(config: ResolvedRelizyConfig, packages: WorkspacePackage[]): string[] | undefined;
+/** Names of the packages containing at least one of the files */
+declare function getPackagesOfFiles(files: string[], packages: WorkspacePackage[]): string[];
+/** The package designated by a scope, if any */
+declare function findPackageByScope(scope: string, packages: WorkspacePackage[]): WorkspacePackage | undefined;
+
+type RuleSeverity = 'error' | 'warn' | 'off';
+/**
+ * What a rule receives to check a commit.
+ */
+interface RuleContext {
+    config: ResolvedRelizyConfig;
+    commit: CommitlintCommit;
+    parts: CommitMessageParts;
+    /** The commit as parsed by relizy, `undefined` when the header is not a conventional commit */
+    gitCommit?: GitCommit;
+    packages: WorkspacePackage[];
+    /** `undefined` when any scope is allowed */
+    allowedScopes?: string[];
+    /** Configured value of the rule, or its default value */
+    value: unknown;
+}
+/** A problem found by a rule: what is wrong, and how to fix it */
+interface RuleProblem {
+    message: string;
+    fix?: string;
+}
+interface RuleDefinition {
+    severity: RuleSeverity;
+    value?: unknown;
+    /** Only run on conventional commits */
+    conventionalOnly?: boolean;
+    check: (context: RuleContext) => RuleProblem[] | Promise<RuleProblem[]>;
+}
+/** `type(scope)!: subject`, lowercase type, a space after the colon */
+declare const STRICT_HEADER_PATTERN: RegExp;
+/**
+ * The built-in rules, with their default severity and value.
+ */
+declare const BUILT_IN_RULES: Record<CommitlintRuleName, RuleDefinition>;
+interface NormalizedRuleConfig {
+    severity: RuleSeverity;
+    /** `undefined` when the config sets no value */
+    value?: unknown;
+}
+/**
+ * `'error'`, `['error', value]` or a commitlint tuple `[2, 'always', value]`.
+ */
+declare function normalizeRuleConfig(name: string, config: CommitlintRuleConfig | undefined): NormalizedRuleConfig | undefined;
+
+/** Documentation of the built-in rules */
+declare const COMMITLINT_RULES_URL = "https://relizy.dev/commitlint/rules";
+interface CommitlintProblem {
+    rule: string;
+    severity: Exclude<RuleSeverity, 'off'>;
+    /** What is wrong */
+    message: string;
+    /** How to fix it */
+    fix?: string;
+    /** Documentation of the rule (built-in rules only) */
+    url?: string;
+}
+interface CommitlintSuggestion {
+    /** The header with the safe fixes applied */
+    header: string;
+    /** Rules still failing with the suggested header */
+    remainingRules: string[];
+}
+interface CommitlintResult {
+    commit: CommitlintCommit;
+    /** Ignored commits (merge, fixup, release...) are not linted */
+    ignored: boolean;
+    /** No error (warnings allowed) */
+    valid: boolean;
+    problems: CommitlintProblem[];
+    /** Title of the changelog section of the commit, `undefined` when it does not appear in the changelog */
+    changelogTitle?: string;
+    /** The commit as parsed by relizy, `undefined` when the header is not a conventional commit */
+    gitCommit?: GitCommit;
+    /** A fixed header, when some errors of the header can be fixed safely */
+    suggestion?: CommitlintSuggestion;
+}
+interface LintCommitMessageOptions {
+    config: ResolvedRelizyConfig;
+    /** Changed files of the commit, relative to the repository root */
+    files?: string[];
+    hash?: string;
+    /** Workspace packages, read from the config when not given */
+    packages?: WorkspacePackage[];
+    /**
+     * Suggest a fixed header
+     * @default true
+     */
+    suggest?: boolean;
+}
+/**
+ * Lint a commit message with the relizy config: the same parser and types as the
+ * release, the workspace packages for the scopes, the changelog rendering for the body.
+ */
+declare function lintCommitMessage(message: string, options: LintCommitMessageOptions): Promise<CommitlintResult>;
+
+interface ReportEntry {
+    result: CommitlintResult;
+    /** Printed before the header: the short hash, or "MR title" / "PR title" */
+    label?: string;
+    /** Changelog entry of the commit, printed with `--preview` */
+    preview?: string;
+}
+interface CommitlintReport {
+    /** `edit`: the commit being created, `message`: a given message, `range`: commits of the history */
+    mode: 'edit' | 'message' | 'range';
+    entries: ReportEntry[];
+    /** Start of the linted range */
+    from?: string;
+    /** Kind of the linted pull/merge request title */
+    titleKind?: PullRequestTitle['kind'];
+    /** File of the message being created, in `edit` mode */
+    messageFile?: string;
+    helpUrl?: string;
+}
+interface CommitlintSummary {
+    errorCount: number;
+    warningCount: number;
+}
+declare function summarizeResults(results: CommitlintResult[]): CommitlintSummary;
+/**
+ * Colors in a terminal and in the CI logs, which render them. Never for a
+ * program reading the output (e.g. an AI agent), nor with `NO_COLOR`.
+ */
+declare function shouldUseColors(stream?: {
+    isTTY?: boolean;
+}): boolean;
+/** `minor bump, 🚀 Enhancements` */
+declare function formatReleaseEffect(result: CommitlintResult): string;
+/**
+ * Lines printed for a linted commit: one line when it is valid without
+ * warning, otherwise its header, each problem with how to fix it, and the
+ * suggested header.
+ */
+declare function formatCommitResult(result: CommitlintResult, { label, colors }?: {
+    label?: string;
+    colors?: boolean;
+}): string[];
+/**
+ * How to fix the invalid commits and title, depending on where they were
+ * linted. The commands to run start with `$ `, so they are never wrapped.
+ */
+declare function formatHowToFix(report: CommitlintReport): string[];
+/**
+ * The text report: each commit, then a summary with the verdict, the
+ * documentation of the failing rules, the help URL and how to fix.
+ */
+declare function formatTextReport(report: CommitlintReport, { colors, quiet }?: {
+    colors?: boolean;
+    /** Only print the commits with problems, and the summary */
+    quiet?: boolean;
+}): string[];
+/**
+ * The JSON report, stable for programs and AI agents: every commit with its
+ * effect on the release, its problems and how to fix them.
+ */
+declare function formatJsonReport(report: CommitlintReport): string;
+/**
+ * GitHub Actions annotations of the problems, displayed on the job summary
+ * and the pull request.
+ */
+declare function formatGithubAnnotations(report: CommitlintReport): string[];
+
 /**
  * Get workspace dependencies of a package (only dependencies and peerDependencies, not devDependencies)
  */
@@ -661,6 +975,11 @@ declare function getPackages({ config, suffix, force, includeAll, dryRun, }: {
     includeAll?: boolean;
     dryRun?: boolean;
 }): Promise<PackageBase[]>;
+declare function isAllowedCommit({ commit, type, changelog, }: {
+    commit: GitCommit;
+    type?: ConfigType;
+    changelog: boolean;
+}): boolean;
 declare function getPackageCommits({ pkg, from, to, config, changelog, dryRun, }: {
     pkg: ReadPackage;
     from: string;
@@ -705,6 +1024,17 @@ declare function getSlackToken(options: {
 declare function getSlackWebhookUrl(options: {
     socialWebhookUrl?: string;
 }): string | null;
+/** Default changelog budget of the `summary` format. */
+declare const SLACK_SUMMARY_MAX_LENGTH = 2500;
+/**
+ * Resolve the changelog budget of a Slack post: `postMaxLength` when set,
+ * otherwise 2500 chars in `summary` format and no limit in `full` format
+ * (the message is then only bounded by Slack's 50 blocks).
+ */
+declare function resolveSlackPostMaxLength({ changelogFormat, postMaxLength }: {
+    changelogFormat?: SlackChangelogFormat;
+    postMaxLength?: number;
+}): number | undefined;
 /**
  * Format changelog for Slack (convert markdown to Slack's mrkdwn format)
  */
@@ -716,9 +1046,14 @@ declare function formatChangelogForSlack(changelog: string, maxLength?: number):
  */
 declare function formatPackagesForSlack(packages: PackageBumpEntry[]): string;
 /**
- * Format the Slack message using blocks
+ * Format the Slack message using blocks.
+ * - `summary` format: the changelog is a single mrkdwn section (2500 chars by default).
+ * - `full` format: the changelog is rendered as rich_text blocks, commit bodies
+ *   included, split per section. It is bounded by `postMaxLength` when set and
+ *   always by Slack's limits (50 blocks, ~13,200 chars for rich text messages).
+ * Every block is kept within Slack's limits so the post is never rejected.
  */
-declare function formatSlackMessage({ projectName, version, changelog, releaseUrl, changelogUrl, template, contributors, packages, postMaxLength }: {
+declare function formatSlackMessage({ projectName, version, changelog, releaseUrl, changelogUrl, template, contributors, packages, postMaxLength, changelogFormat }: {
     template?: string;
     projectName: string;
     version: string;
@@ -728,17 +1063,112 @@ declare function formatSlackMessage({ projectName, version, changelog, releaseUr
     contributors?: string[];
     packages?: PackageBumpEntry[];
     postMaxLength?: number;
+    changelogFormat?: SlackChangelogFormat;
 }): any[];
 /**
  * Post a release announcement to Slack.
  * Dispatches to Incoming Webhook (if `webhookUrl` is set) or Web API (`token` + `channel`).
  * When both are provided, the webhook takes priority.
  */
-declare function postReleaseToSlack({ version, projectName, changelog, releaseUrl, changelogUrl, channel, token, webhookUrl, template, contributors, packages, postMaxLength, dryRun, }: SlackOptions): Promise<{
+declare function postReleaseToSlack({ version, projectName, changelog, releaseUrl, changelogUrl, channel, token, webhookUrl, template, contributors, packages, postMaxLength, changelogFormat, dryRun, }: SlackOptions): Promise<{
     ok: true;
     transport: "webhook";
 } | _slack_web_api.ChatPostMessageResponse | undefined>;
 
+/** Maximum number of blocks in a Slack message. */
+declare const SLACK_MAX_BLOCKS = 50;
+/** Maximum length of the text of a Slack section block. */
+declare const SLACK_SECTION_MAX_LENGTH = 3000;
+/**
+ * Soft cap of the text carried by a single rich_text block. Slack documents no
+ * limit for rich_text, so the section limit is reused as a conservative bound.
+ */
+declare const SLACK_RICH_TEXT_BLOCK_MAX_LENGTH = 3000;
+/**
+ * Budget of the JSON of all the blocks of a message containing rich_text blocks.
+ * Slack rejects such messages above ~13,200 characters with `msg_blocks_too_long`
+ * (https://github.com/slackapi/bolt-js/issues/2509): measuring the JSON, which is
+ * larger than the text Slack counts, keeps a safe margin.
+ */
+declare const SLACK_RICH_TEXT_MESSAGE_MAX_LENGTH = 11000;
+/** Maximum length of the text of a Slack header block. */
+declare const SLACK_HEADER_MAX_LENGTH = 150;
+interface SlackRichTextStyle {
+    bold?: boolean;
+    italic?: boolean;
+    strike?: boolean;
+    code?: boolean;
+}
+interface SlackRichTextText {
+    type: 'text';
+    text: string;
+    style?: SlackRichTextStyle;
+}
+interface SlackRichTextLink {
+    type: 'link';
+    url: string;
+    text?: string;
+    style?: SlackRichTextStyle;
+}
+type SlackRichTextInline = SlackRichTextText | SlackRichTextLink;
+interface SlackRichTextSection {
+    type: 'rich_text_section';
+    elements: SlackRichTextInline[];
+}
+interface SlackRichTextList {
+    type: 'rich_text_list';
+    style: 'bullet' | 'ordered';
+    indent?: number;
+    offset?: number;
+    elements: SlackRichTextSection[];
+}
+interface SlackRichTextQuote {
+    type: 'rich_text_quote';
+    elements: SlackRichTextInline[];
+}
+interface SlackRichTextPreformatted {
+    type: 'rich_text_preformatted';
+    elements: SlackRichTextInline[];
+}
+type SlackRichTextElement = SlackRichTextSection | SlackRichTextList | SlackRichTextQuote | SlackRichTextPreformatted;
+interface SlackRichTextBlock {
+    type: 'rich_text';
+    elements: SlackRichTextElement[];
+}
+/** Cut a text without splitting a UTF-16 surrogate pair (emoji), which Slack would render broken. */
+declare function sliceSlackText(text: string, length: number): string;
+/**
+ * Render a markdown changelog as Slack mrkdwn.
+ * When `maxLength` is exceeded, whole commits are dropped from the end and
+ * replaced with an "… and N more changes" line; a single block longer than
+ * the budget is cut instead.
+ */
+declare function markdownToSlackMrkdwn(markdown: string, { maxLength, cutCommits }?: {
+    maxLength?: number;
+    /** Cut the first commit that does not fit where the limit is reached, instead of dropping it whole */
+    cutCommits?: boolean;
+}): string;
+/**
+ * Render a markdown changelog as Slack rich_text blocks.
+ * Commit bodies are rendered under their bullet: paragraphs as quotes, nested
+ * lists as indented lists, code as preformatted blocks.
+ * When `maxLength`, `maxBlocks` or `maxPayloadLength` is exceeded, the changelog
+ * is cut where the limit is reached, even inside a commit body, with an ellipsis,
+ * and the commits left out entirely are announced with an "… and N more changes" line.
+ */
+declare function markdownToSlackRichText(markdown: string, { maxLength, maxBlocks, maxPayloadLength, blockMaxLength, }?: {
+    /** Maximum number of text characters of the changelog */
+    maxLength?: number;
+    /** Maximum number of returned blocks */
+    maxBlocks?: number;
+    /** Maximum length of the JSON of the returned blocks */
+    maxPayloadLength?: number;
+    /** Soft cap of the text characters of a single block */
+    blockMaxLength?: number;
+}): SlackRichTextBlock[];
+/** Plain-text rendering of a rich_text block, used for dry-run previews. */
+declare function richTextToPlainText(block: SlackRichTextBlock): string;
+
 /**
  * Extract a summary from changelog content
  */
@@ -1470,6 +1900,10 @@ interface SocialOptions {
      * true = force-enable AI, false = force-disable AI, undefined = use config
      */
     ai?: boolean;
+    /**
+     * Override `social.slack.changelogFormat` for this run
+     */
+    slackFormat?: SlackChangelogFormat;
     /**
      * Prerelease suffix, forwarded to package discovery in independent mode
      * when no bump result is available (standalone `social` runs).
@@ -1738,6 +2172,10 @@ interface ReleaseOptions extends ReleaseConfig, BumpConfig, ChangelogConfig, Pub
      * true = force-enable AI, false = force-disable AI, undefined = use config
      */
     ai?: boolean;
+    /**
+     * Override `social.slack.changelogFormat` for this run
+     */
+    slackFormat?: SlackChangelogFormat;
 }
 interface TwitterCredentials {
     /**
@@ -1794,6 +2232,12 @@ interface SlackCredentials {
      */
     token?: string;
 }
+/**
+ * Slack changelog rendering:
+ * - `summary`: short changelog (commit titles only) in a single mrkdwn section.
+ * - `full`: complete changelog (commit bodies and PR/issue links) rendered as rich text blocks.
+ */
+type SlackChangelogFormat = 'summary' | 'full';
 interface SlackSocialConfig {
     /**
      * Enable Slack posting
@@ -1827,10 +2271,22 @@ interface SlackSocialConfig {
      * Slack credentials (optional - falls back to environment variables)
      */
     credentials?: SlackCredentials;
+    /**
+     * Changelog rendering of the Slack message.
+     * - `summary`: commit titles only, in a single section capped at `postMaxLength`.
+     * - `full`: commit bodies and PR/issue links included, rendered as rich text blocks
+     *   (one per changelog section). Commit bodies follow `changelog.includeCommitBody`.
+     * Can be overridden with the `--slack-format` CLI flag.
+     * @default 'summary'
+     */
+    changelogFormat?: SlackChangelogFormat;
     /**
      * Maximum length (in characters) of the changelog rendered inside the Slack message.
-     * Slack's per-section-block limit is 3000; default 2500 leaves margin for emoji/formatting.
-     * @default 2500
+     * When exceeded, `summary` drops the last commits, `full` cuts the changelog where the limit
+     * is reached (even inside a commit body) with an ellipsis; the commits left out entirely are
+     * announced with an "… and N more changes" line.
+     * Defaults to 2500 in `summary` format (Slack's section limit is 3000) and to no limit
+     * in `full` format, where the message is only bounded by Slack's 50 blocks.
      */
     postMaxLength?: number;
     /**
@@ -1878,6 +2334,12 @@ interface AiSdkProviderOptions {
 }
 type AIPromptTarget = 'providerRelease' | 'twitter' | 'slack';
 type AISystemPromptOverrides = Partial<Record<AIPromptTarget, string>>;
+interface AIExtraGuidelines extends Partial<Record<AIPromptTarget, string>> {
+    /**
+     * Directives appended to every target, before the target-specific ones
+     */
+    global?: string;
+}
 interface AITargetConfig {
     /**
      * Enable AI for this target
@@ -1921,10 +2383,13 @@ interface AIConfig {
      */
     fallback?: 'raw' | 'fail';
     /**
-     * Extra directives appended to every built-in system prompt.
+     * Extra directives appended to the built-in system prompts.
+     * A string applies to every target; an object adds directives per target,
+     * appended after the `global` ones.
      * @example 'Always use emojis in the changelog'
+     * @example { global: 'Keep package names in English.', slack: 'Mention the owning team.' }
      */
-    extraGuidelines?: string;
+    extraGuidelines?: string | AIExtraGuidelines;
     /**
      * Full replacement of the built-in system prompts.
      * When set, the extraGuidelines and base prompts are ignored for that target.
@@ -2038,9 +2503,14 @@ interface SlackOptions {
     template?: string;
     /**
      * Maximum chars of the changelog rendered in the message.
-     * @default 2500
+     * Defaults to 2500 in `summary` format and to no limit in `full` format.
      */
     postMaxLength?: number;
+    /**
+     * Changelog rendering of the message
+     * @default 'summary'
+     */
+    changelogFormat?: SlackChangelogFormat;
     /**
      * Contributor names (plain strings, no email/handle). Empty array or undefined → no contributors block.
      */
@@ -2204,6 +2674,202 @@ type HookConfig = {
         changelog: string;
     }) => string | void | null | undefined | Promise<string | void | null | undefined>;
 };
+/**
+ * Severity of a commitlint rule: `error` (or `2`) fails the check, `warn` (or `1`)
+ * reports without failing, `off` (or `0`) disables the rule.
+ */
+type CommitlintRuleLevel = 'error' | 'warn' | 'off' | 0 | 1 | 2;
+/**
+ * Configuration of a commitlint rule: a level, a level and a value (ESLint style),
+ * or a commitlint tuple `[level, 'always', value]` to ease migrations.
+ * A rule without value accepts the commitlint tuple `[level, 'always']`.
+ */
+type CommitlintRuleConfig<Value = unknown> = CommitlintRuleLevel | readonly [CommitlintRuleLevel] | readonly [CommitlintRuleLevel, [Value] extends [never] ? 'always' | 'never' : Value] | readonly [CommitlintRuleLevel, 'always' | 'never', Value];
+/**
+ * The built-in rules of `relizy commitlint`, with the type of their value
+ * (`never` when the rule has no value).
+ * @see https://relizy.dev/commitlint/rules
+ */
+interface CommitlintBuiltInRules {
+    /**
+     * The header follows `type(scope)!: subject`.
+     * @default 'error'
+     */
+    'header-format': never;
+    /**
+     * Maximum length of the header.
+     * @default ['error', 500]
+     */
+    'header-max-length': number;
+    /**
+     * The type is one of the relizy `types`, or one of the extra types given as value.
+     * @default 'error'
+     */
+    'type-enum': string[];
+    /**
+     * The scope is a workspace package, a `scopeMap` key or one of `commitlint.scopes`.
+     * @default 'error'
+     */
+    'scope-enum': never;
+    /**
+     * The scope is required (`'always'`), forbidden (`'never'`), or required on
+     * the commits bumping a version (`'when-bumping'`).
+     * @default ['off', 'always']
+     */
+    'scope-required': 'always' | 'never' | 'when-bumping';
+    /**
+     * The scope designates a package touched by the commit.
+     * @default 'warn'
+     */
+    'scope-matches-files': never;
+    /**
+     * The subject starts with a lowercase letter.
+     * @default 'error'
+     */
+    'subject-case': never;
+    /**
+     * The subject does not end with a period.
+     * @default 'error'
+     */
+    'subject-full-stop': never;
+    /**
+     * The subject describes the change, with a minimum of words or characters.
+     * @default ['error', { minWords: 2, minLength: 15 }]
+     */
+    'subject-meaningful': {
+        minWords?: number;
+        minLength?: number;
+    };
+    /**
+     * A blank line separates the header from the body.
+     * @default 'error'
+     */
+    'body-leading-blank': never;
+    /**
+     * The body has no markdown headings, which would break the changelog.
+     * @default 'error'
+     */
+    'body-no-headings': never;
+    /**
+     * The markdown of the body is valid: code blocks closed, links with a URL.
+     * @default 'error'
+     */
+    'body-markdown': never;
+    /**
+     * The commit, rendered as in the changelogs, passes the lint of the changelogs.
+     * @default 'error'
+     */
+    'body-changelog-lint': never;
+    /**
+     * A breaking change is only declared with `!` in the header or a `BREAKING CHANGE:`
+     * footer, as relizy bumps the major version wherever `breaking change:` appears.
+     * @default 'error'
+     */
+    'body-breaking-change': never;
+    /**
+     * Breaking changes are not allowed.
+     * @default 'off'
+     */
+    'no-breaking': never;
+}
+type CommitlintRuleName = keyof CommitlintBuiltInRules;
+/**
+ * Configuration of the built-in rules, typed per rule, and of the custom rules.
+ */
+type CommitlintRulesConfig = {
+    [Name in keyof CommitlintBuiltInRules]?: CommitlintRuleConfig<CommitlintBuiltInRules[Name]>;
+} & Record<string, CommitlintRuleConfig>;
+/**
+ * A commit message parsed by `relizy commitlint`, with the commitlint field names,
+ * enriched with what relizy knows about the commit.
+ */
+interface CommitlintCommit {
+    /** Full message, comments removed */
+    raw: string;
+    /** First line of the message */
+    header: string;
+    /** Text between the header and the footer */
+    body: string;
+    /** Trailing block of `Token: value` lines (`BREAKING CHANGE:`, `Closes #12`...) */
+    footer: string;
+    /** Type, empty when the header is not a conventional commit */
+    type: string;
+    /** Scope, as written in the header */
+    scope: string;
+    /** Description of the header, as written */
+    subject: string;
+    /** Breaking change as detected by relizy (`!` or `breaking change:` in the body) */
+    isBreaking: boolean;
+    /** Version bump the commit triggers, computed by relizy from `types` */
+    bump?: SemverBumpType;
+    /** Pull request, issue and hash references found by relizy */
+    references: Reference$1[];
+    /** Changed files (staged files, or the files of the commit in a range), when known */
+    files?: string[];
+    /** Names of the workspace packages touched by `files` */
+    packages?: string[];
+    /** Hash of the commit, when linting a range */
+    hash?: string;
+}
+interface CommitlintCustomRuleContext {
+    /** Value configured for the rule (`['error', value]`) */
+    value: unknown;
+    /** Resolved relizy config */
+    config: ResolvedRelizyConfig;
+}
+/**
+ * A rule written as a function. Returns `true` when the commit is valid, an
+ * error message (or `false`) otherwise, or a commitlint-style `[valid, message?]`
+ * tuple so `commitlint-plugin-function-rules` rules can be copied as is.
+ */
+type CommitlintCustomRule = (commit: CommitlintCommit, context: CommitlintCustomRuleContext) => CommitlintCustomRuleOutcome | Promise<CommitlintCustomRuleOutcome>;
+type CommitlintCustomRuleOutcome = boolean | string | [boolean, string?];
+interface CommitlintConfig {
+    /**
+     * Glob patterns of directories to treat as workspace packages for the scopes,
+     * in addition to `monorepo.packages`, e.g. apps that are never released.
+     * @example ['apps/*']
+     */
+    packages?: string[];
+    /**
+     * Scopes allowed in addition to the workspace packages (short name, full name
+     * or folder) and the `scopeMap` keys. In standalone mode, scopes are free
+     * unless this list is set.
+     * @example ['ci', 'deps', 'release']
+     */
+    scopes?: string[];
+    /**
+     * Level and value of the built-in and custom rules.
+     * @example { 'header-max-length': ['error', 200], 'scope-required': ['error', 'when-bumping'] }
+     */
+    rules?: CommitlintRulesConfig;
+    /**
+     * Rules written as functions, keyed by name. Their level is set in `rules`
+     * and defaults to `error`.
+     */
+    customRules?: Record<string, CommitlintCustomRule>;
+    /**
+     * Messages to ignore, in addition to the default ones: a regular expression
+     * tested against the header, or a function receiving the raw message.
+     */
+    ignores?: Array<RegExp | ((message: string) => boolean)>;
+    /**
+     * Ignore merge commits, `fixup!`, `squash!` and `amend!` commits, and the
+     * release commits of relizy.
+     * @default true
+     */
+    defaultIgnores?: boolean;
+    /**
+     * In the CI of a pull/merge request, also lint its title, which becomes the
+     * commit message of a squash merge. Overridden by `--title` and `--no-title`.
+     * @default false
+     */
+    title?: boolean;
+    /**
+     * URL printed with the errors, e.g. the commit guidelines of the team.
+     */
+    helpUrl?: string;
+}
 /**
  * Relizy configuration
  * @see https://relizy.dev/config/overview
@@ -2280,6 +2946,11 @@ interface RelizyConfig extends Partial<Omit<ChangelogConfig$1, 'output' | 'templ
      * Hooks config
      */
     hooks?: HookConfig;
+    /**
+     * Commit message linter (`relizy commitlint`) config
+     * @see https://relizy.dev/commitlint/
+     */
+    commitlint?: CommitlintConfig;
     /**
      * Set log level
      * @default 'default'
@@ -2314,6 +2985,62 @@ declare function bump(options?: Partial<BumpOptions>): Promise<BumpResult>;
 
 declare function changelog(options?: Partial<ChangelogOptions>): Promise<void>;
 
+interface CommitlintOptions {
+    /**
+     * Lint the message of the commit being created: the file given to the
+     * `commit-msg` hook, or `.git/COMMIT_EDITMSG` when `true`.
+     */
+    edit?: string | boolean;
+    /** Lint this message */
+    message?: string;
+    /**
+     * Lint the commits after this ref. Defaults to the merge-base with the target
+     * branch of the pull/merge request in CI, otherwise the last tag.
+     */
+    from?: string;
+    /**
+     * Last commit of the range
+     * @default 'HEAD'
+     */
+    to?: string;
+    /**
+     * In the CI of a pull/merge request, also lint its title, which becomes the
+     * commit message of a squash merge
+     * @default config.commitlint.title
+     */
+    title?: boolean;
+    /** Print the changelog entry of each commit */
+    preview?: boolean;
+    /**
+     * `text` for people (colors in a terminal or a CI), `json` for programs and AI agents
+     * @default 'text'
+     */
+    format?: 'text' | 'json';
+    /** In the text format, only print the commits with problems, and the summary */
+    quiet?: boolean;
+    /** Write the `commit-msg` hook instead of linting */
+    install?: boolean;
+    /** Replace an existing `commit-msg` hook with `install` */
+    force?: boolean;
+    /** Custom config file name (e.g. `relizy.standalone` for `relizy.standalone.config.ts`) */
+    configName?: string;
+    logLevel?: LogLevel;
+    /** Pre-loaded config */
+    config?: ResolvedRelizyConfig;
+}
+interface CommitlintRunResult extends CommitlintSummary {
+    results: CommitlintResult[];
+    /** The linted commits and how to fix them, unset with `install` */
+    report?: CommitlintReport;
+    /** Set when the hook was installed */
+    hook?: InstalledHook;
+}
+/**
+ * Lint commit messages with the relizy config: the commit being created
+ * (`edit`), a message, or a range of commits. Errors make `errorCount` positive.
+ */
+declare function commitlint(options?: CommitlintOptions): Promise<CommitlintRunResult>;
+
 interface PrCommentOptions {
     prNumber?: number;
     dryRun?: boolean;
@@ -2391,5 +3118,5 @@ declare function socialSafetyCheck({ config }: {
 }): Promise<void>;
 declare function social(options?: Partial<SocialOptions>): Promise<SocialResult>;
 
-export { NEW_PACKAGE_MARKER, PR_COMMENT_MARKER, assertBranchUpToDateWithRemote, assertReleaseTagsAvailable, buildChangelogBody, buildCommentBody, buildCompareLink, buildContributors, buildReleaseSummary, bump, capReleaseTypeForZeroMajor, changelog, checkGitStatusIfDirty, collectContributorNames, collectPackageBumps, confirmBump, createCommitAndTags, createGitlabRelease, defineConfig, detectGitProvider, detectPackageManager, detectPullRequest, determinePublishTag, determineReleaseType, determineSemverChange, executeBuildCmd, executeFormatCmd, executeHook, expandPackagesToBumpWithDependents, extractChangelogSummary, extractVersionFromPackageTag, extractVersionFromRepoTag, extractVersionFromTag, fetchGitTags, filterOutPrivatePackages, filterPrivatePackagesUnlessIncluded, findGitHubPR, findGitLabMR, findReachableCommitBySubject, formatChangelogForSlack, formatPackagesForSlack, formatSlackMessage, formatTweetMessage, generateChangelog, generateMarkDown, getAuthCommand, getBumpedIndependentPackages, getBumpedPackageIndependently, getCIName, getCanaryVersion, getCommitChangedFiles, getCommitSubject, getCurrentGitBranch, getCurrentGitRef, getDefaultConfig, getDependentsOf, getFirstCommit, getGitDiff, getGitStatus, getGitUpstream, getIndependentTag, getLastPackageTag, getLastRepoTag, getLastStableTag, getLastTag, getModifiedReleaseFilePatterns, getNewPackageCompareBase, getNpmRegistry, getPackageCommits, getPackageDependencies, getPackageNewVersion, getPackages, getPackagesOrBumpedPackages, getPackagesToPublishInIndependentMode, getPackagesToPublishInSelectiveMode, getPreid, getReleaseTagNames, getReleaseUrl, getRootPackage, getShortCommitSha, getSlackToken, getSlackWebhookUrl, getTwitterCredentials, github, gitlab, globDirsAbsolute, hasLernaJson, isAncestor, isBumpedPackage, isChangedPreid, isCommitOnlyInIgnoredPackages, isGraduating, isGraduatingToStableBetweenVersion, isInCI, isPrerelease, isPrereleaseReleaseType, isStableReleaseType, isTagVersionCompatibleWithCurrent, isVersionAlreadyPublishedError, isVersionPublished, listTags, loadRelizyConfig, mergeTypes, parseChangelogMarkdown, parseGitRemoteUrl, postPrComment, postReleaseToSlack, postReleaseToTwitter, prComment, providerRelease, providerReleaseSafetyCheck, publish, publishPackage, publishSafetyCheck, pushCommitAndTags, pushTagForce, readPackageJson, readPackages, reconcileFromTag, redactSecrets, release, resetRewrittenTagCache, resolveAllConfiguredRegistryTargets, resolveIgnoredPackagePaths, resolveRegistryTargetsForPackage, resolveRegistryTargetsForPackages, resolveTags, retagAnnotatedLocal, rollbackModifiedFiles, shouldFilterPrereleaseTags, social, socialSafetyCheck, tagExists, topologicalSort, tryPostPrComment, updateLernaVersion, withRegistryNpmrc, writeChangelogToFile, writeVersion };
-export type { AIConfig, AIPromptTarget, AIProviderName, AISocialConfig, AISystemPromptOverrides, AITargetConfig, AiSdkProviderOptions, BumpConfig, BumpOptions, BumpResult, BumpResultFalsy, BumpResultTruthy, ChangelogConfig, ChangelogInclude, ChangelogOptions, ClaudeCodeProviderOptions, ConfigType, GitProvider, GitUpstream, GitlabRelease, GitlabReleaseResponse, HookConfig, HookStep, HookType, MonorepoConfig, OnRewrittenTag, PackageBase, PackageBumpEntry, PackageManager, PostedRelease, PrCommentConfig, PrCommentMode, PrCommentOptions, PrCommentStatus, ProviderReleaseOptions, ProviderReleaseResult, PublishConfig, PublishOptions, PublishResponse, PullRequestInfo, ReadPackage, Reference, RegistryTarget, ReleaseConfig, ReleaseContext, ReleaseOptions, RelizyConfig, RepoConfig, ResolvedConfig, ResolvedRelizyConfig, ResolvedTags, ResolvedTwitterCredentials, RootPackage, SlackCredentials, SlackOptions, SlackPackageEntry, SlackSocialConfig, SocialConfig, SocialNetworkResult, SocialOptions, SocialResult, Step, TemplatesConfig, TokensConfig, TwitterCredentials, TwitterOptions, TwitterSocialConfig, VersionMode };
+export { BUILT_IN_RULES, COMMITLINT_RULES_URL, NEW_PACKAGE_MARKER, PR_COMMENT_MARKER, SLACK_HEADER_MAX_LENGTH, SLACK_MAX_BLOCKS, SLACK_RICH_TEXT_BLOCK_MAX_LENGTH, SLACK_RICH_TEXT_MESSAGE_MAX_LENGTH, SLACK_SECTION_MAX_LENGTH, SLACK_SUMMARY_MAX_LENGTH, STRICT_HEADER_PATTERN, assertBranchUpToDateWithRemote, assertRefAvailable, assertReleaseTagsAvailable, buildChangelogBody, buildCommentBody, buildCompareLink, buildContributors, buildReleaseSummary, bump, capReleaseTypeForZeroMajor, changelog, checkGitStatusIfDirty, collectContributorNames, collectPackageBumps, commitlint, confirmBump, createCommitAndTags, createGitlabRelease, defineConfig, detectGitProvider, detectPackageManager, detectPullRequest, determinePublishTag, determineReleaseType, determineSemverChange, executeBuildCmd, executeFormatCmd, executeHook, expandPackagesToBumpWithDependents, extractChangelogSummary, extractVersionFromPackageTag, extractVersionFromRepoTag, extractVersionFromTag, fetchGitTags, filterOutPrivatePackages, filterPrivatePackagesUnlessIncluded, findGitHubPR, findGitLabMR, findPackageByScope, findReachableCommitBySubject, formatChangelogForSlack, formatCommitResult, formatGithubAnnotations, formatHowToFix, formatJsonReport, formatPackagesForSlack, formatReleaseEffect, formatSlackMessage, formatTextReport, formatTweetMessage, generateChangelog, generateMarkDown, getAllowedScopes, getAuthCommand, getBumpedIndependentPackages, getBumpedPackageIndependently, getCIName, getCanaryVersion, getChangelogLinter, getChangelogTitle, getCommentChar, getCommitChangedFiles, getCommitMessageFile, getCommitSubject, getCommitsInRange, getCurrentGitBranch, getCurrentGitRef, getDefaultConfig, getDependentsOf, getFirstCommit, getGitDiff, getGitStatus, getGitUpstream, getIndependentTag, getLastPackageTag, getLastRepoTag, getLastStableTag, getLastTag, getModifiedReleaseFilePatterns, getNewPackageCompareBase, getNpmRegistry, getPackageCommits, getPackageDependencies, getPackageNewVersion, getPackages, getPackagesOfFiles, getPackagesOrBumpedPackages, getPackagesToPublishInIndependentMode, getPackagesToPublishInSelectiveMode, getPreid, getPullRequestTitle, getReleaseTagNames, getReleaseUrl, getRootPackage, getShortCommitSha, getSlackToken, getSlackWebhookUrl, getStagedFiles, getTwitterCredentials, getWorkspacePackages, github, gitlab, globDirsAbsolute, hasLernaJson, installCommitMsgHook, isAllowedCommit, isAncestor, isBumpedPackage, isChangedPreid, isCommitOnlyInIgnoredPackages, isGraduating, isGraduatingToStableBetweenVersion, isIgnoredCommitMessage, isInCI, isPrerelease, isPrereleaseReleaseType, isStableReleaseType, isTagVersionCompatibleWithCurrent, isVersionAlreadyPublishedError, isVersionPublished, lintCommitMessage, listTags, loadRelizyConfig, markdownToSlackMrkdwn, markdownToSlackRichText, mergeTypes, normalizeRuleConfig, parseChangelogMarkdown, parseGitRemoteUrl, postPrComment, postReleaseToSlack, postReleaseToTwitter, prComment, providerRelease, providerReleaseSafetyCheck, publish, publishPackage, publishSafetyCheck, pushCommitAndTags, pushTagForce, readCommitMessageFile, readPackageJson, readPackages, reconcileFromTag, redactSecrets, release, renderChangelogEntry, resetRewrittenTagCache, resolveAllConfiguredRegistryTargets, resolveDefaultRangeStart, resolveIgnoredPackagePaths, resolveRegistryTargetsForPackage, resolveRegistryTargetsForPackages, resolveSlackPostMaxLength, resolveTags, retagAnnotatedLocal, richTextToPlainText, rollbackModifiedFiles, shouldFilterPrereleaseTags, shouldUseColors, sliceSlackText, social, socialSafetyCheck, splitCommitMessage, stripGitComments, summarizeResults, tagExists, topologicalSort, tryPostPrComment, updateLernaVersion, withRegistryNpmrc, writeChangelogToFile, writeVersion };
+export type { AIConfig, AIExtraGuidelines, AIPromptTarget, AIProviderName, AISocialConfig, AISystemPromptOverrides, AITargetConfig, AiSdkProviderOptions, BumpConfig, BumpOptions, BumpResult, BumpResultFalsy, BumpResultTruthy, ChangelogConfig, ChangelogInclude, ChangelogLinter, ChangelogOptions, ClaudeCodeProviderOptions, CommitMessageParts, CommitlintBuiltInRules, CommitlintCommit, CommitlintConfig, CommitlintCustomRule, CommitlintCustomRuleContext, CommitlintCustomRuleOutcome, CommitlintOptions, CommitlintProblem, CommitlintReport, CommitlintResult, CommitlintRuleConfig, CommitlintRuleLevel, CommitlintRuleName, CommitlintRulesConfig, CommitlintRunResult, CommitlintSuggestion, CommitlintSummary, ConfigType, DefaultRangeStart, GitProvider, GitUpstream, GitlabRelease, GitlabReleaseResponse, HookConfig, HookStep, HookType, InstalledHook, LintCommitMessageOptions, MonorepoConfig, NormalizedRuleConfig, OnRewrittenTag, PackageBase, PackageBumpEntry, PackageManager, PostedRelease, PrCommentConfig, PrCommentMode, PrCommentOptions, PrCommentStatus, ProviderReleaseOptions, ProviderReleaseResult, PublishConfig, PublishOptions, PublishResponse, PullRequestInfo, PullRequestTitle, RangeCommit, ReadPackage, Reference, RegistryTarget, ReleaseConfig, ReleaseContext, ReleaseOptions, RelizyConfig, RepoConfig, ReportEntry, ResolvedConfig, ResolvedRelizyConfig, ResolvedTags, ResolvedTwitterCredentials, RootPackage, RuleContext, RuleDefinition, RuleProblem, RuleSeverity, SlackChangelogFormat, SlackCredentials, SlackOptions, SlackPackageEntry, SlackRichTextBlock, SlackRichTextElement, SlackRichTextInline, SlackRichTextLink, SlackRichTextList, SlackRichTextPreformatted, SlackRichTextQuote, SlackRichTextSection, SlackRichTextStyle, SlackRichTextText, SlackSocialConfig, SocialConfig, SocialNetworkResult, SocialOptions, SocialResult, Step, TemplatesConfig, TokensConfig, TwitterCredentials, TwitterOptions, TwitterSocialConfig, VersionMode, WorkspacePackage };