relizy 1.9.0 → 1.11.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;
@@ -137,6 +138,331 @@ 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. With `auto`, its ESLint when
+ * it lints the CHANGELOG.md files, otherwise a syntax check of the code blocks
+ * with oxc. Loaded once per cwd and choice.
+ */
+declare function getChangelogLinter(cwd: string, choice?: CommitlintCodeBlocksLinter): 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[];
+/**
+ * Makes sure the start of the range is in the local history: in a shallow
+ * clone of the CI, the history and the tags are fetched. Throws a helpful
+ * error when it is still missing.
+ */
+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[];
+}
+/**
+ * Package globs declared by the tools of the monorepo: the `workspaces` of the
+ * package.json (npm, yarn, bun, and Turborepo or Nx on top of them),
+ * `pnpm-workspace.yaml`, `lerna.json`, `rush.json` and the `workspace` of `deno.json`.
+ */
+declare function getPackageManagerWorkspaces(cwd: string): string[];
+/**
+ * Packages of the monorepo, private ones included: a commit can touch a package
+ * that is never published. Besides `monorepo.packages`, the workspace of the
+ * package manager and `commitlint.packages` add the 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. Extra spaces
+ * are accepted: the changelog trims them.
+ */
+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 +987,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;
@@ -2355,6 +2686,216 @@ 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. Off by default: the changelog
+     * capitalizes the subject anyway.
+     * @default 'off'
+     */
+    '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?];
+/**
+ * Tool checking the code blocks of the commit bodies (`body-changelog-lint`):
+ * - `auto`: the ESLint of the project when it lints the CHANGELOG.md files, otherwise `oxc`;
+ * - `eslint`: the ESLint of the project, an error when it does not lint the CHANGELOG.md files;
+ * - `oxc`: a syntax check of the JavaScript, TypeScript and JSON code blocks.
+ */
+type CommitlintCodeBlocksLinter = 'auto' | 'eslint' | 'oxc';
+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;
+    /**
+     * Tool checking the code blocks of the commit bodies, rendered as in the
+     * changelogs (`body-changelog-lint`).
+     * @default 'auto'
+     */
+    codeBlocksLinter?: CommitlintCodeBlocksLinter;
+    /**
+     * URL printed with the errors, e.g. the commit guidelines of the team.
+     */
+    helpUrl?: string;
+}
 /**
  * Relizy configuration
  * @see https://relizy.dev/config/overview
@@ -2431,6 +2972,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'
@@ -2465,6 +3011,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;
@@ -2542,5 +3144,5 @@ declare function socialSafetyCheck({ config }: {
 }): Promise<void>;
 declare function social(options?: Partial<SocialOptions>): Promise<SocialResult>;
 
-export { 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, 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, markdownToSlackMrkdwn, markdownToSlackRichText, mergeTypes, parseChangelogMarkdown, parseGitRemoteUrl, postPrComment, postReleaseToSlack, postReleaseToTwitter, prComment, providerRelease, providerReleaseSafetyCheck, publish, publishPackage, publishSafetyCheck, pushCommitAndTags, pushTagForce, readPackageJson, readPackages, reconcileFromTag, redactSecrets, release, resetRewrittenTagCache, resolveAllConfiguredRegistryTargets, resolveIgnoredPackagePaths, resolveRegistryTargetsForPackage, resolveRegistryTargetsForPackages, resolveSlackPostMaxLength, resolveTags, retagAnnotatedLocal, richTextToPlainText, rollbackModifiedFiles, shouldFilterPrereleaseTags, sliceSlackText, social, socialSafetyCheck, tagExists, topologicalSort, tryPostPrComment, updateLernaVersion, withRegistryNpmrc, writeChangelogToFile, writeVersion };
-export type { AIConfig, AIExtraGuidelines, 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, 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 };
+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, getPackageManagerWorkspaces, 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, CommitlintCodeBlocksLinter, 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 };