commit-check 2.19.0__py3-none-any.whl → 2.19.2__py3-none-any.whl

commit_check/__init__.py

@@ -90,7 +90,7 @@ DEFAULT_BRANCH_TYPES = [
     "dependabot",
     "renovate",
 ]
-# Additional allowed branch names (e.g., develop, staging)
+# Additional allowed branch names (e.g., staging, production)
 DEFAULT_BRANCH_NAMES: list[str] = []
 
 # Tag naming default: SemVer, with an optional leading "v" (v1.2.3 or 1.2.3),
@@ -104,6 +104,21 @@ DEFAULT_TAG_REGEX = (
     r"(?:\+[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*)?$"
 )
 
+# The subjects merge tools write themselves, which no subject rule judges and
+# CC006 alone decides on. git's fmt-merge-msg writes "Merge branch 'x'" (and
+# "branches", "remote-tracking branch", "tag", "commit", each possibly
+# plural), or "Merge <url>" when pulling a remote's HEAD; GitLab writes
+# "Merge branch 'x' into 'y'", GitHub and Bitbucket "Merge pull request #N
+# ...", and the merge refs CI checks out read "Merge <sha> into <sha>".
+# Anything else starting "Merge " is author prose and is held to the rules
+# like any other subject. Unanchored, so it can be embedded in a larger
+# pattern; match it with re.match.
+GIT_MERGE_SUBJECT_PATTERN = (
+    r"Merge (?:(?:remote-tracking )?branch(?:es)? '|tags? '|commits? '"
+    r"|pull request #|[0-9a-f]{7,64} into [0-9a-f]{7,64}\b"
+    r"|[a-z][a-z0-9+.-]*://|[\w.-]+@[\w.-]+:)"
+)
+
 # Push-related defaults
 DEFAULT_PUSH_RULES = {
     "allow_force_push": True,

commit_check/ai_signatures.py

@@ -95,8 +95,13 @@ def _build_groups() -> list[_Group]:
         # instead, it is entered on every line the branch rejects, at a cost
         # that grows with each tool added to the catalog.
         branches = "|".join(f"(?:{value})(?P<s{i}>)" for i, value in enumerate(values))
+        # The value starts and ends on a non-blank character, so the spaces
+        # around it belong to the ``[ \t]*`` beside it and nowhere else.
+        # Values that open with ``[^<\n]*`` or close with ``[ \t]*`` could
+        # otherwise share them, and a long run of spaces was tried every way
+        # it splits: seconds for a 30 KB line.
         regex = re.compile(
-            rf"^(?:{alternation}):[ \t]*(?:{branches})[ \t]*$",
+            rf"^(?:{alternation})[ \t]*:[ \t]*(?=\S)(?:{branches})(?<![ \t])[ \t]*$",
             re.IGNORECASE | re.MULTILINE,
         )
         groups.append(_Group(keys, regex, tuple(members)))
@@ -122,7 +127,7 @@ def _scans() -> tuple[re.Pattern[str], ...]:
 
 #: The key of a trailer-shaped line, e.g. ``Co-authored-by`` in
 #: ``Co-authored-by: Claude``.
-_TRAILER_KEY = re.compile(r"([A-Za-z][A-Za-z0-9-]*):")
+_TRAILER_KEY = re.compile(r"([A-Za-z][A-Za-z0-9-]*)[ \t]*:")
 
 
 def _trailer_lines(message: str) -> list[tuple[str, str]]:
@@ -248,7 +253,8 @@ def find_trailers(message: str, keys: list[str]) -> list[tuple[str, str, str]]:
     """Every trailer line in *message* whose key is one of *keys*.
 
     Keys match case-insensitively, at the start of any line — the reading
-    the signature scanner and the sign-off rule take too.
+    the signature scanner and the sign-off rule take too. Blanks may precede
+    the colon, as git allows.
 
     :returns: ``(key as written, value, line)`` per match, in message order;
         the value is empty for a trailer that names nothing.
@@ -256,11 +262,13 @@ def find_trailers(message: str, keys: list[str]) -> list[tuple[str, str, str]]:
     if not keys:
         return []
     alternation = "|".join(re.escape(key) for key in keys)
-    # A carriage return before the newline is line ending, not value.
+    # The value runs to the end of the line and is trimmed afterwards: a lazy
+    # value before ``[ \t\r]*$`` re-scans trailing spaces at every step. A
+    # carriage return before the newline is line ending, not value.
     pattern = re.compile(
-        rf"^({alternation}):[ \t]*([^\n]*?)[ \t\r]*$", re.IGNORECASE | re.MULTILINE
+        rf"^({alternation})[ \t]*:[ \t]*([^\n]*)$", re.IGNORECASE | re.MULTILINE
     )
     return [
-        (match.group(1), match.group(2), match.group(0))
+        (match.group(1), match.group(2).rstrip(" \t\r"), match.group(0))
         for match in pattern.finditer(message)
     ]

commit_check/ai_signatures_data.py

@@ -90,11 +90,15 @@ def _trailer(
     """Build a trailer pattern for a structured ``Key: value`` line.
 
     The match is case-insensitive and anchors the key at the start of a line.
-    Horizontal whitespace only around the value: ``\\s`` would let a match run
-    on to the next trailer line and report two lines as one.
+    Blanks may precede the colon, because git reads ``Key : value`` as the
+    trailer ``Key: value``. Horizontal whitespace only around the value:
+    ``\\s`` would let a match run on to the next trailer line and report two
+    lines as one. The value starts and ends on a non-blank character, so a
+    long run of spaces around it can be read only one way; see
+    ``ai_signatures._build_groups``.
     """
     alternation = "|".join(re.escape(key) for key in keys)
-    raw = rf"^(?:{alternation}):[ \t]*{value_pattern}[ \t]*$"
+    raw = rf"^(?:{alternation})[ \t]*:[ \t]*(?=\S)(?:{value_pattern})(?<![ \t])[ \t]*$"
     return AiSignaturePattern(
         regex=re.compile(raw, re.IGNORECASE | re.MULTILINE),
         kind="trailer",
@@ -189,6 +193,10 @@ CLAUDE_CODE = KnownAiTool(
 )
 
 # --- GitHub Copilot ---
+# The coding agent links each of its commits to the session logs with an
+# ``Agent-Logs-Url`` trailer, and a squash merge of its pull request credits
+# it as ``copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>``:
+# https://github.blog/changelog/2026-03-20-trace-any-copilot-coding-agent-commit-to-its-session-logs
 COPILOT = KnownAiTool(
     name="GitHub Copilot",
     name_pattern=_names(r"copilot"),
@@ -197,6 +205,13 @@ COPILOT = KnownAiTool(
             r"Copilot(?:[ \t]*<\d+\+Copilot@users\.noreply\.github\.com>)?",
             "Copilot",
         ),
+        # Only the Copilot account has this address, so it catches the agent
+        # under any display name.
+        *_identity(
+            r"[^<\n]*<\d+\+Copilot@users\.noreply\.github\.com>",
+            "... <N+Copilot@users.noreply.github.com>",
+        ),
+        _stamp_trailer("Agent-Logs-Url", "``Agent-Logs-Url:`` trailer"),
     ],
 )
 
@@ -223,7 +238,10 @@ CURSOR = KnownAiTool(
     name="Cursor",
     name_pattern=_names(r"cursor"),
     patterns=[
-        *_identity(r"Cursor[ \t]*(?:<[^>\n]*>)?", "Cursor"),
+        *_identity(r"Cursor(?: Agent)?[ \t]*(?:<[^>\n]*>)?", "Cursor"),
+        # Cursor's agent signs as ``Cursor Agent <cursoragent@cursor.com>``;
+        # the address catches it under any display name.
+        *_identity(r"[^<\n]*<cursoragent@cursor\.com>", "... <cursoragent@cursor.com>"),
     ],
 )
 

commit_check/config.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import copy
 import io
+import os
+import stat
 import sys
 import urllib.error
 import urllib.request
@@ -140,28 +142,63 @@ class _LazyOpener:
 _opener = _LazyOpener()
 
 
+# The largest parent config ``inherit_from`` will read, from a URL or a file.
+# A real policy file is a few kilobytes; the cap is there so that a path such
+# as ``/dev/zero``, or a URL that never stops sending, fails like any other
+# parent that cannot be loaded instead of filling memory.
+MAX_PARENT_CONFIG_BYTES = 1024 * 1024
+
+
+def _read_capped(f: Any) -> bytes:
+    """Read at most :data:`MAX_PARENT_CONFIG_BYTES` from *f*.
+
+    One byte more than the cap is requested, so a body that is exactly at
+    the cap is accepted and anything longer is told apart from it.
+
+    :raises ValueError: If *f* holds more than the cap.
+    """
+    data = f.read(MAX_PARENT_CONFIG_BYTES + 1)
+    if len(data) > MAX_PARENT_CONFIG_BYTES:
+        raise ValueError(
+            f"larger than the {MAX_PARENT_CONFIG_BYTES // (1024 * 1024)} MiB limit"
+        )
+    return data
+
+
 def _load_from_url(url: str) -> dict[str, Any]:
     """Load TOML config from an HTTPS URL.
 
     :param url: HTTPS URL pointing to a TOML config file.
     :returns: Parsed config dict.
-    :raises ValueError: If the URL does not use HTTPS, or the fetched body is
-        not valid TOML (``TOMLDecodeError``).
+    :raises ValueError: If the URL does not use HTTPS, the body is larger than
+        :data:`MAX_PARENT_CONFIG_BYTES`, or it is not valid TOML
+        (``TOMLDecodeError``).
     :raises OSError: If the URL cannot be fetched, or redirects off HTTPS
         (``urllib.error.URLError`` is an ``OSError``).
     """
     if not url.startswith("https://"):
         raise ValueError("only https:// URLs are accepted")
     with _opener.open(url, timeout=10) as response:
-        data = response.read()
+        data = _read_capped(response)
     return toml_load(io.BytesIO(data))
 
 
-def _load_parent_config(inherit_from: str) -> dict[str, Any]:
+def _load_parent_config(
+    inherit_from: str, base_dir: Path | None = None
+) -> dict[str, Any]:
     """Load the parent config named by an ``inherit_from`` value.
 
+    A relative local path is looked for next to the config file that names
+    it (*base_dir*) first, so the reference holds wherever the CLI is run
+    from, then in the current directory, where it used to be resolved alone,
+    and last at the top of the git work tree, which is where the current
+    directory was for a config written against that before a run from a
+    subdirectory could find it.
+
     :raises ValueError: For a malformed ``github:`` shorthand, a non-HTTPS URL,
-        or a parent that is not valid TOML (``TOMLDecodeError``).
+        a local path that is not a regular file, a parent larger than
+        :data:`MAX_PARENT_CONFIG_BYTES`, or one that is not valid TOML
+        (``TOMLDecodeError``).
     :raises OSError: For an unreachable URL or an unreadable local file.
     """
     if inherit_from.startswith("github:"):
@@ -171,11 +208,26 @@ def _load_parent_config(inherit_from: str) -> dict[str, Any]:
         return _load_from_url(url)
     if inherit_from.startswith(("https://", "http://")):
         return _load_from_url(inherit_from)
-    with open(Path(inherit_from), "rb") as f:
-        return toml_load(f)
+    path = Path(inherit_from)
+    if not path.is_absolute():
+        if base_dir is not None and (base_dir / path).exists():
+            path = base_dir / path
+        elif not path.exists():
+            root = _config_search_root()
+            if root is not None and (root / path).exists():
+                path = root / path
+    # Checked before opening: a device such as /dev/zero never ends, and
+    # opening a FIFO blocks until something writes to it.
+    if not stat.S_ISREG(os.stat(path).st_mode):
+        raise ValueError("not a regular file")
+    with open(path, "rb") as f:
+        data = _read_capped(f)
+    return toml_load(io.BytesIO(data))
 
 
-def _resolve_inherit_from(config: dict[str, Any]) -> dict[str, Any]:
+def _resolve_inherit_from(
+    config: dict[str, Any], base_dir: Path | None = None
+) -> dict[str, Any]:
     """Resolve ``inherit_from`` directive, merging parent config with local.
 
     The ``inherit_from`` key at the top level of a config file may be:
@@ -187,7 +239,11 @@ def _resolve_inherit_from(config: dict[str, Any]) -> dict[str, Any]:
     HTTP (non-TLS) URLs are rejected to prevent MITM attacks.  The parent
     config is loaded first; local settings override the parent.
 
+    Only one level is followed: an ``inherit_from`` in the parent itself is
+    dropped with a notice rather than fetched.
+
     :param config: Already-parsed local TOML dict (may contain ``inherit_from``).
+    :param base_dir: Directory of the config file, for a relative local path.
     :returns: Merged config with parent settings applied as base.
     """
     inherit_from = config.pop("inherit_from", None)
@@ -200,7 +256,7 @@ def _resolve_inherit_from(config: dict[str, Any]) -> dict[str, Any]:
     # TOMLDecodeError (tomllib and tomli alike) is a ValueError; URLError is
     # an OSError.
     try:
-        parent = _load_parent_config(inherit_from)
+        parent = _load_parent_config(inherit_from, base_dir)
     except (OSError, ValueError) as e:
         print(
             f'⊘ inherit_from "{inherit_from}" could not be loaded: {e}; '
@@ -209,6 +265,16 @@ def _resolve_inherit_from(config: dict[str, Any]) -> dict[str, Any]:
         )
         parent = {}
 
+    # Left in place it would reach the merged config and be reported as an
+    # unknown setting, which reads as a typo rather than a limit.
+    if "inherit_from" in parent:
+        nested = parent.pop("inherit_from")
+        print(
+            f'⊘ inherit_from "{nested}" in the parent config "{inherit_from}" is '
+            "ignored: only one level of inherit_from is followed",
+            file=sys.stderr,
+        )
+
     if parent:
         deep_merge(parent, config)
         return parent
@@ -233,13 +299,40 @@ def _load_toml_file(path: Path, shown_as: str | None = None) -> dict[str, Any]:
             raise ConfigError(f"{shown_as or path}: {e}") from e
 
 
+def _config_search_root() -> Path | None:
+    """The top of the git work tree, or ``None`` outside one.
+
+    The default config paths are repository locations: run from a
+    subdirectory, a search relative to the current directory found nothing
+    and the run went ahead on the built-in defaults without a word.
+
+    The top is the nearest directory up from the current one that holds a
+    ``.git`` directory, or a ``.git`` file as in a linked worktree or a
+    submodule. Looking for it costs a few ``stat`` calls where ``git
+    rev-parse --show-toplevel`` cost a process on every run without a config.
+    """
+    # os.path rather than pathlib: this runs on every run without a config,
+    # and building a Path per parent costs several times the stat calls.
+    directory = os.getcwd()
+    while True:
+        if os.path.exists(os.path.join(directory, ".git")):
+            return Path(directory)
+        parent = os.path.dirname(directory)
+        if parent == directory:
+            return None
+        directory = parent
+
+
 def find_config_path(path_hint: str = "") -> Path | None:
     """The config file a run reads, or ``None`` when there is none.
 
     With ``path_hint`` that is the hint, canonicalised, if it exists. Without
-    one it is the first of :data:`DEFAULT_CONFIG_PATHS` that exists. Kept
-    separate from :func:`load_config` so an error found later, in a setting
-    the merged dict no longer attributes to a file, can still name the file.
+    one it is the first of :data:`DEFAULT_CONFIG_PATHS` that exists in the
+    current directory, as before, or failing that at the top of the git work
+    tree, given in full. A package in a monorepo with a config of its own
+    keeps using it. Kept separate from :func:`load_config` so an error found
+    later, in a setting the merged dict no longer attributes to a file, can
+    still name the file.
     """
     if path_hint:
         p = Path(path_hint).resolve()
@@ -247,6 +340,13 @@ def find_config_path(path_hint: str = "") -> Path | None:
     for candidate in DEFAULT_CONFIG_PATHS:
         if candidate.exists():
             return candidate
+    root = _config_search_root()
+    if root is None or root == Path.cwd():
+        # The current directory was searched above.
+        return None
+    for candidate in DEFAULT_CONFIG_PATHS:
+        if (root / candidate).exists():
+            return root / candidate
     return None
 
 
@@ -266,4 +366,6 @@ def load_config(path_hint: str = "") -> dict[str, Any]:
             raise FileNotFoundError(f"Specified config file not found: {path_hint}")
         # No default config file: run on the built-in defaults.
         return {}
-    return _resolve_inherit_from(_load_toml_file(path, shown_as=path_hint or None))
+    return _resolve_inherit_from(
+        _load_toml_file(path, shown_as=path_hint or None), path.parent
+    )

commit_check/engine.py

@@ -13,7 +13,11 @@ from enum import IntEnum
 from fnmatch import fnmatchcase
 from typing import ClassVar
 
-from commit_check import DEFAULT_AI_DISCLOSURE_TRAILERS, ai_policy
+from commit_check import (
+    DEFAULT_AI_DISCLOSURE_TRAILERS,
+    GIT_MERGE_SUBJECT_PATTERN,
+    ai_policy,
+)
 from commit_check.ai_signatures import (
     detect_ai_signatures,
 )
@@ -47,9 +51,28 @@ from commit_check.util import (
     git_rev_parse_verify,
     has_commits,
     print_error_header,
+    read_commit_message_file,
     rejection_headline,
 )
 
+_GIT_MERGE_SUBJECT = re.compile(GIT_MERGE_SUBJECT_PATTERN)
+
+
+def is_merge_subject(subject: str) -> bool:
+    """Whether *subject* is one a merge tool wrote, not the author.
+
+    The subject rules decline to judge these. A subject that merely starts
+    with the word ("Merge lowercase parser tables") is the author's, and is
+    judged like any other.
+    """
+    return _GIT_MERGE_SUBJECT.match(subject) is not None
+
+
+# A work-in-progress marker at the start of the subject (CC010). "^" without
+# re.MULTILINE and "[ \t]*" rather than "\s*" keep the match on the first
+# line, so a body that merely mentions WIP is not a WIP commit.
+_WIP_MARKER = re.compile(r"^[ \t]*(?:\[wip\]|wip\b)", re.IGNORECASE)
+
 
 class ValidationResult(IntEnum):
     """Validation result codes.
@@ -286,8 +309,7 @@ class BaseValidator(ABC):
 
         if context.commit_file:
             try:
-                with open(context.commit_file, "r", encoding="utf-8") as f:
-                    return f.read().strip()
+                return read_commit_message_file(context.commit_file).strip()
             except FileNotFoundError:
                 pass
 
@@ -341,8 +363,7 @@ class BaseValidator(ABC):
             return context.stdin_text
         if context.commit_file:
             try:
-                with open(context.commit_file, "r", encoding="utf-8") as f:
-                    return f.read()
+                return read_commit_message_file(context.commit_file)
             except OSError:
                 pass
         if context.rev is not None:
@@ -482,9 +503,8 @@ class SubjectValidator(BaseValidator):
 
         if context.commit_file:
             try:
-                with open(context.commit_file, "r", encoding="utf-8") as f:
-                    message = f.read().strip()
-                    return message.split("\n")[0]
+                message = read_commit_message_file(context.commit_file).strip()
+                return message.split("\n")[0]
             except FileNotFoundError:
                 pass
 
@@ -496,14 +516,32 @@ class SubjectValidator(BaseValidator):
         """Override in subclasses for specific validation logic."""
         return ValidationResult.PASS
 
+    def _description(self, subject: str) -> str:
+        """*subject* past its Conventional Commits ``type(scope)!:`` prefix.
+
+        The rule's ``allowed`` list says which words are types: the builder
+        sets it to ``allow_commit_types`` under Conventional Commits and to
+        an empty list without them, where "Added: support" or "oops: x" is
+        not a type but the subject itself. ``None``, from a rule built by
+        hand, keeps the old reading of any ``word:`` as a type.
+        """
+        match = re.match(r"^(\w+)(?:\([^)]*\))?!?:\s*(.*)", subject)
+        if not match:
+            return subject
+        allowed = self.rule.allowed
+        if allowed is not None and match.group(1) not in allowed:
+            return subject
+        return match.group(2)
+
 
 class SubjectCapitalizationValidator(SubjectValidator):
     """Validates that subject starts with capital letter."""
 
     def _validate_subject(self, subject: str) -> ValidationResult:
         # A merge subject is machine-written; the rule declines to judge it.
-        # Git writes "Merge " exactly, so anything else is author prose.
-        if subject.startswith("Merge "):
+        # Only the subjects merge tools write count, so anything else is
+        # author prose.
+        if is_merge_subject(subject):
             return ValidationResult.SKIP
 
         if self._is_capitalized(subject):
@@ -516,8 +554,7 @@ class SubjectCapitalizationValidator(SubjectValidator):
         self._print_failure(subject, fix=fix)
         return ValidationResult.FAIL
 
-    @staticmethod
-    def _is_capitalized(subject: str) -> bool:
+    def _is_capitalized(self, subject: str) -> bool:
         """Whether the description starts upper-case, after any Conventional Commits prefix.
 
         Only a prefix that ends in a colon is a type. Without one, the first
@@ -525,8 +562,7 @@ class SubjectCapitalizationValidator(SubjectValidator):
         "A" and not on the "f" that follows, and "Update" alone is judged at
         all.
         """
-        match = re.match(r"^\w+(?:\([^)]*\))?!?:\s*(.*)", subject)
-        description = match.group(1).strip() if match else subject
+        description = self._description(subject).strip()
         return bool(description) and description[0].isupper()
 
 
@@ -548,14 +584,14 @@ class SubjectImperativeValidator(SubjectValidator):
 
     def _validate_subject(self, subject: str) -> ValidationResult:
         # Merge and fixup subjects are machine-written; decline to judge them.
-        # Git writes "Merge " and "fixup! " exactly, so anything else is
-        # author prose.
-        if subject.startswith(("Merge ", "fixup! ")):
+        # Only the subjects merge tools write, and git's exact "fixup! ",
+        # count, so anything else is author prose.
+        if is_merge_subject(subject) or subject.startswith("fixup! "):
             return ValidationResult.SKIP
 
-        # Extract first word (ignore conventional commit prefixes)
-        # support breaking changes (feat!:)
-        match = re.match(r"^(?:\w+(?:\([^)]*\))?!?:\s*)?(\w+)", subject)
+        # Extract first word, past a Conventional Commits prefix (including
+        # a breaking "feat!:") when there is one.
+        match = re.match(r"(\w+)", self._description(subject))
         if not match:
             return ValidationResult.PASS
 
@@ -606,7 +642,7 @@ class SubjectLengthValidator(SubjectValidator):
 
     def _validate_subject(self, subject: str) -> ValidationResult:
         # A merge subject's length is git's doing, not the author's.
-        if subject.startswith("Merge "):
+        if is_merge_subject(subject):
             return ValidationResult.SKIP
 
         length = len(subject)
@@ -752,7 +788,10 @@ class TagValidator(BaseValidator):
         pre-push hook receives. For push lines the tags under push are the
         ``refs/tags/*`` refs — a push carrying no tag ref yields nothing to
         validate, and a deletion (all-zero local sha) removes a tag rather
-        than naming a new one, so neither can fail the check.
+        than naming a new one, so neither can fail the check. The remote ref
+        is the name checked, because it is the one the remote receives:
+        ``git push origin v1.0.0:refs/tags/anything`` creates ``anything``.
+        The local ref stands in only when the remote side is not a tag.
         """
         lines = [ln.strip() for ln in text.splitlines() if ln.strip()]
         push_lines = [ln for ln in lines if len(ln.split()) == 4 and "refs/" in ln]
@@ -762,7 +801,7 @@ class TagValidator(BaseValidator):
                 local_ref, local_sha, remote_ref, _ = ln.split()
                 if set(local_sha) == {"0"}:
                     continue
-                for ref in (local_ref, remote_ref):
+                for ref in (remote_ref, local_ref):
                     if ref.startswith("refs/tags/"):
                         tags.append(ref.removeprefix("refs/tags/"))
                         break
@@ -991,7 +1030,12 @@ class MergeBaseValidator(BaseValidator):
         # Find target branch matching the pattern
         target_branch = self._find_target_branch(target_pattern)
         if not target_branch:
-            return ValidationResult.PASS
+            # A target that resolves to no ref (a typo, or a shallow CI clone
+            # without origin/<target>) leaves nothing to compare. That is a
+            # skip, not a pass: the branch was never judged against it.
+            name = target_pattern.lstrip("^").rstrip("$").strip()
+            self._skip_reason = f"rebase target '{name}' not found"
+            return ValidationResult.SKIP
 
         result = git_merge_base(target_branch, current_branch)
         if result == 128:
@@ -1374,18 +1418,23 @@ class CommitTypeValidator(BaseValidator):
         return not is_empty or self.rule.value
 
     def _is_fixup_commit_allowed(self, message: str) -> bool:
-        """Check if fixup commits are allowed."""
-        is_fixup = message.startswith("fixup!")
+        """Check if fixup commits are allowed.
+
+        ``git commit --fixup`` writes ``fixup!``, ``--squash`` writes
+        ``squash!`` and ``--fixup=amend:``/``--fixup=reword:`` write
+        ``amend!``. ``git rebase --autosquash`` folds all three away, so all
+        three are the commits this rule is about.
+        """
+        is_fixup = message.startswith(("fixup!", "squash!", "amend!"))
         return not is_fixup or self.rule.value
 
     def _is_wip_commit_allowed(self, message: str) -> bool:
         """Check if WIP commits are allowed."""
-        upper_msg = message.upper()
-        is_wip = (
-            # wip: / [wip] / "wip " at the start, in any case
-            upper_msg.startswith(("WIP:", "[WIP]", "WIP "))
-            or upper_msg == "WIP"  # exact WIP
-        )
+        # [wip] or the word "wip" opening the subject, in any case and
+        # whatever follows it: "WIP:", "WIP add", "WIP-", "WIP\t", or "WIP"
+        # alone on the subject line. The word boundary keeps "wipe ..." out;
+        # this is the marker fix_wip knows how to drop.
+        is_wip = _WIP_MARKER.match(message) is not None
         return not is_wip or self.rule.value
 
 

commit_check/fixes.py

@@ -17,7 +17,10 @@ from collections.abc import Mapping
 
 # type, optional scope, optional bang, optional colon, the rest. Lenient on
 # purpose: this is the shape of a subject that *tried* to be conventional.
-_HEADER = re.compile(r"^\s*([A-Za-z]+)(\([^)]*\))?(!)?(\s*:\s*|\s+)(\S.*?)\s*$")
+# The description ends on its last non-space character, found greedily: a
+# lazy ``.*?`` before ``\s*$`` re-scans the trailing spaces at every step,
+# which took seconds on a subject holding a long run of them.
+_HEADER = re.compile(r"^\s*([A-Za-z]+)(\([^)]*\))?(!)?(\s*:\s*|\s+)(\S(?:.*\S)?)\s*$")
 _CONVENTIONAL_PREFIX = re.compile(r"^(\w+(?:\([^)]*\))?!?:\s*)(.*)$")
 _WIP = re.compile(r"^\s*(?:\[wip\]|wip:|wip\b)\s*[-:]?\s*", re.IGNORECASE)
 

commit_check/main.py

@@ -24,6 +24,7 @@ from commit_check.util import (
     get_remote_branch_sha,
     git_rev_parse_verify,
     print_error_header,
+    split_message_comments,
 )
 
 from . import AI_ATTRIBUTION_POLICIES, __version__
@@ -355,7 +356,7 @@ def _get_parser() -> argparse.ArgumentParser:
         type=parse_bool,
         default=None,
         metavar="BOOL",
-        help="allow fixup commits (true/false)",
+        help="allow fixup!, squash! and amend! commits (true/false)",
     )
 
     commit_group.add_argument(
@@ -548,7 +549,8 @@ def _fix_message_file(path: str, rules: list, config: dict) -> None:
     """
     with open(path, encoding="utf-8") as f:
         original = f.read()
-    message = original.strip()
+    message, comments = split_message_comments(original)
+    message = message.strip()
     engine = ValidationEngine([r for r in rules if r.check in MESSAGE_CHECKS])
     fixed = []
     for _ in range(len(engine.rules) + 1):
@@ -569,8 +571,15 @@ def _fix_message_file(path: str, rules: list, config: dict) -> None:
         fixed.append(f"{first.rule_id} {first.check.replace('_', '-')}")
     if failed or not fixed:
         return
+    # The comment block and a scissors line with the diff below it stay in
+    # the file, after the message where git's own template puts them, so
+    # git's cleanup after the hook still finds and removes them.
+    if comments:
+        rewritten = f"{message}\n\n{comments}"
+    else:
+        rewritten = original.replace(original.strip(), message, 1)
     with open(path, "w", encoding="utf-8") as f:
-        f.write(original.replace(original.strip(), message, 1))
+        f.write(rewritten)
     print(f"✎ fixed the commit message: {', '.join(fixed)}", file=sys.stderr)
 
 
@@ -824,7 +833,9 @@ def main() -> int:
         print(f"Error: {e}", file=sys.stderr)
         return EXIT_CONFIG_ERROR
     except Exception as e:  # noqa: BLE001 - last resort: report it, no traceback
-        print(f"Error: {e}", file=sys.stderr)
+        # Some exceptions carry no text (MemoryError, a bare KeyError()), and
+        # "Error: " on its own says nothing; name the type instead.
+        print(f"Error: {str(e) or type(e).__name__}", file=sys.stderr)
         return EXIT_FAIL
 
 

commit_check/rule_builder.py

@@ -18,6 +18,7 @@ from commit_check import (
     DEFAULT_COMMIT_TYPES,
     DEFAULT_PUSH_RULES,
     DEFAULT_TAG_REGEX,
+    GIT_MERGE_SUBJECT_PATTERN,
 )
 from commit_check.config import ConfigError
 from commit_check.rules_catalog import (
@@ -153,6 +154,46 @@ def _checked_regex(pattern: str, setting: str) -> str:
     return pattern
 
 
+def _string_setting(value: Any, setting: str) -> str:
+    """*value*, once it is known to be a string, stripped.
+
+    A number or a boolean used to reach ``.strip()`` and come back from
+    main's catch-all as "'int' object has no attribute 'strip'" under exit
+    code 1, the code a rejected commit gets.
+    """
+    if not isinstance(value, str):
+        raise ConfigError(f"{setting} must be a string, got {value!r}", setting=setting)
+    return value.strip()
+
+
+def _string_list(
+    section: dict[str, Any], key: str, default: list[str], setting: str
+) -> list[str]:
+    """``section[key]`` as a list of strings, a comma-separated string split.
+
+    ``--allow-commit-types`` and ``CCHK_ALLOW_COMMIT_TYPES`` already split
+    on commas; the same string in the TOML file was iterated letter by
+    letter, so ``"feat,fix"`` allowed a type called ``f``. Anything else
+    that is not a list of strings is refused rather than guessed at.
+    """
+    value = section.get(key, default)
+    # The built-in default needs no checking, and this runs on every rule
+    # set built, so it is returned as is.
+    if value is default:
+        return value
+    if isinstance(value, list):
+        for item in value:
+            if not isinstance(item, str):
+                break
+        else:
+            return value
+    elif isinstance(value, str):
+        return [item.strip() for item in value.split(",") if item.strip()]
+    raise ConfigError(
+        f"{setting} must be a list of strings, got {value!r}", setting=setting
+    )
+
+
 class RuleBuilder:
     """Builds validation rules from config and catalog entries."""
 
@@ -445,7 +486,9 @@ class RuleBuilder:
         enforce custom formats such as JIRA smart commits
         (``PROJ-123: description``).
         """
-        custom_pattern = self.commit_config.get("message_pattern", "").strip()
+        custom_pattern = _string_setting(
+            self.commit_config.get("message_pattern", ""), "[commit] message_pattern"
+        )
         if custom_pattern:
             custom_pattern = _checked_regex(custom_pattern, "[commit] message_pattern")
             # A team that opted out of Conventional Commits must not be told
@@ -506,8 +549,14 @@ class RuleBuilder:
     ) -> ValidationRule | None:
         """Build subject length validation rule."""
         length = self.commit_config.get(config_key)
-        if not isinstance(length, int):
+        if length is None:
             return None
+        # bool is an int: ``true`` used to become a limit of 1 character.
+        if isinstance(length, bool) or not isinstance(length, int):
+            setting = f"[commit] {config_key}"
+            raise ConfigError(
+                f"{setting} must be a whole number, got {length!r}", setting=setting
+            )
 
         # The suggestion is templated on the same values as the error: naming
         # the configured length is the whole point of the advice, and "the
@@ -547,10 +596,10 @@ class RuleBuilder:
     ) -> ValidationRule | None:
         """Build author name or email validation rule."""
         regex = catalog_entry.regex
-        if self.commit_config.get(config_key, ""):
-            regex = _checked_regex(
-                self.commit_config.get(config_key, "").strip(), f"[commit] {config_key}"
-            )
+        setting = f"[commit] {config_key}"
+        configured = _string_setting(self.commit_config.get(config_key, ""), setting)
+        if configured:
+            regex = _checked_regex(configured, setting)
 
         return ValidationRule(
             check=catalog_entry.check,
@@ -697,27 +746,54 @@ class RuleBuilder:
         ):
             return None
 
+        # The case and mood rules judge the description, so they look past a
+        # "type(scope)!:" prefix -- but only a prefix that is one: a type the
+        # team allows, under Conventional Commits. With those off, "Added:
+        # support" or "oops: lowercase" is the subject itself and is judged
+        # from its first word. An empty list tells the validator to strip
+        # nothing.
+        allowed = None
+        if check in ("subject_capitalized", "subject_imperative"):
+            conventional = self.commit_config.get("conventional_commits", True)
+            allowed = self._get_allowed_commit_types() if conventional else []
+
         return ValidationRule(
             check=catalog_entry.check,
             regex=catalog_entry.regex,
             error=catalog_entry.error,
             suggest=catalog_entry.suggest,
             value=config_value,
+            allowed=allowed,
         )
 
     def _get_allowed_commit_types(self) -> list[str]:
         """Get deduplicated list of allowed commit types."""
-        types = self.commit_config.get("allow_commit_types", DEFAULT_COMMIT_TYPES)
+        types = _string_list(
+            self.commit_config,
+            "allow_commit_types",
+            DEFAULT_COMMIT_TYPES,
+            "[commit] allow_commit_types",
+        )
         return list(dict.fromkeys(types))  # Preserve order, remove duplicates
 
     def _get_allowed_branch_types(self) -> list[str]:
         """Get deduplicated list of allowed branch types."""
-        types = self.branch_config.get("allow_branch_types", DEFAULT_BRANCH_TYPES)
+        types = _string_list(
+            self.branch_config,
+            "allow_branch_types",
+            DEFAULT_BRANCH_TYPES,
+            "[branch] allow_branch_types",
+        )
         return list(dict.fromkeys(types))  # Preserve order, remove duplicates
 
     def _get_allowed_branch_names(self) -> list[str]:
         """Get deduplicated list of allowed branch names."""
-        names = self.branch_config.get("allow_branch_names", DEFAULT_BRANCH_NAMES)
+        names = _string_list(
+            self.branch_config,
+            "allow_branch_names",
+            DEFAULT_BRANCH_NAMES,
+            "[branch] allow_branch_names",
+        )
         return list(dict.fromkeys(names))  # Preserve order, remove duplicates
 
     def _build_conventional_commit_regex(self, allowed_types: list[str]) -> str:
@@ -726,9 +802,11 @@ class RuleBuilder:
         # Subjects git writes itself are exempt from the format rule; whether
         # they are allowed at all is CC006/CC007/CC009's call. Git writes each
         # prefix exactly as below, trailing space or quote included, so author
-        # prose such as "Merged ..." or "fixup!! ..." is still held to the
-        # format.
-        git_prefixes = r'^(?:Merge |Revert "|fixup! |squash! |amend! )'
+        # prose such as "Merged ...", "Merge the parser tables" or
+        # "fixup!! ..." is still held to the format.
+        git_prefixes = (
+            rf'^(?:{GIT_MERGE_SUBJECT_PATTERN}|Revert "|fixup! |squash! |amend! )'
+        )
         return (
             rf"^({types_pattern})(\([\w\-\.]+\))?(!)?: [^\n]+([\s\S]*)|{git_prefixes}"
         )
@@ -742,8 +820,9 @@ class RuleBuilder:
         # always been: the built-in "PR-.+" is one, and the Action's own
         # config allows "create-pull-request/.+" that way. Every alternative
         # is anchored at both ends so a name has to match the whole branch
-        # name, not merely its start ("main-backup" is not "main").
-        names_pattern = "master|main|HEAD|PR-.+"
+        # name, not merely its start ("main-backup" is not "main"). develop
+        # is the specification's third trunk branch, beside main and master.
+        names_pattern = "master|main|develop|HEAD|PR-.+"
         if allowed_names:
             names_pattern += "|" + "|".join(allowed_names)
         description_pattern = (

commit_check/rules_catalog.py

@@ -134,7 +134,7 @@ COMMIT_RULES = [
         check="allow_fixup_commits",
         regex=None,
         error="Fixup commits are not allowed",
-        suggest="Use interactive rebase to clean up fixup commits",
+        suggest="Fold fixup!, squash! and amend! commits with git rebase -i --autosquash",
     ),
     RuleCatalogEntry(
         rule_id="CC010",
@@ -179,7 +179,11 @@ COMMIT_RULES = [
     RuleCatalogEntry(
         rule_id="CC012",
         check="require_signed_off_by",
-        regex=r"Signed-off-by: .+ <.+@.+>",
+        # A whole line, so the words in a subject or a sentence of the body
+        # are not a sign-off, and with the key's case ignored, as git does.
+        # No two parts can match the same characters, which keeps matching
+        # linear: overlapping ``.+`` runs took seconds on a 6 KB line.
+        regex=r"(?mi)^Signed-off-by:[ \t]*[^<\s][^<\n]*<[^>@\n]+@[^>\n]+>[ \t\r]*$",
         error="Signed-off-by trailer not found in the latest commit",
         suggest="git commit --amend --signoff or use --signoff on commit",
     ),

commit_check/util.py

@@ -8,6 +8,7 @@ A module containing utility functions.
 from __future__ import annotations
 
 import os
+import re
 import subprocess
 import sys
 from collections.abc import Iterable
@@ -16,6 +17,34 @@ from subprocess import CalledProcessError
 from commit_check import GREEN, RED, RESET_COLOR, YELLOW
 from commit_check.rules_catalog import display_name
 
+# C0 and C1 control characters, and DEL, except the newline and tab that a
+# multi-line commit message legitimately carries.
+_CONTROL_CHARS = re.compile(r"[\x00-\x08\x0b-\x1f\x7f-\x9f]")
+
+
+def printable(text: str) -> str:
+    """Make commit-controlled text safe to print as terminal or CI-log text.
+
+    The values printed on failure come from whoever wrote the commit, branch
+    or tag. Printed raw, an escape sequence in them drives the reader's
+    terminal (OSC 52 can write the clipboard), and a line beginning with
+    ``::`` is a GitHub Actions workflow command, able to forge annotations
+    or mask log text. So control characters are shown as ``\\xNN`` escapes,
+    and such a line gets a backslash before its ``::`` — the runner ignores
+    leading whitespace, so indenting it would not be enough. The runner also
+    reads the older ``##[command]`` form anywhere in a line, so ``##[`` is
+    broken up the same way. JSON output is escaped by the encoder and does
+    not pass through here.
+    """
+    if text.isprintable() and "::" not in text and "##[" not in text:
+        return text  # nothing to escape: the common case
+    text = _CONTROL_CHARS.sub(lambda m: f"\\x{ord(m.group()):02x}", text)
+    text = text.replace("##[", "#\\#[")
+    return "\n".join(
+        line.replace("::", "\\::", 1) if line.lstrip().startswith("::") else line
+        for line in text.split("\n")
+    )
+
 
 def _print_failure(
     check: dict,
@@ -32,7 +61,7 @@ def _print_failure(
     rule_id = check.get("rule_id", "")
     warn = check.get("severity") == "warn"
     if compact:
-        compact_value = actual.splitlines()[0] if actual else actual
+        compact_value = printable(actual.splitlines()[0]) if actual else actual
         name = display_name(check["check"])
         label = f"{rule_id} {name}" if rule_id else name
         print(f"[{'WARN' if warn else 'FAIL'}] {label}: {compact_value}")
@@ -41,10 +70,12 @@ def _print_failure(
     if not warn and not no_banner and not print_error_header.has_been_called:
         print_error_header(rejection_headline([check["check"]]))
     docs_url = check.get("docs_url", "") or ""
+    # The value, and an error or suggestion built from it, are the commit's
+    # text; see printable() for why they are not printed raw.
     print_error_message(
         check["check"],
-        check.get("error", ""),
-        actual,
+        printable(check.get("error", "")),
+        printable(actual),
         rule_id=rule_id,
         docs_url=docs_url,
         warn=warn,
@@ -52,7 +83,7 @@ def _print_failure(
         spec_url=check.get("spec_url", "") or "",
     )
     if check.get("suggest"):
-        print_suggestion(check["suggest"])
+        print_suggestion(printable(check["suggest"]))
     # When the ID above is already a link, repeating the URL only adds a line
     # to read. Without hyperlink support — a pipe, a CI log — it is the only
     # way the reader gets the address at all, so it stays.
@@ -566,6 +597,81 @@ def get_git_config_value(key: str) -> str:
         return ""
 
 
+# git's scissors line, after the comment character and a space. ``git commit
+# -v`` writes it above the diff, and git drops it and everything below it.
+SCISSORS_LINE = "------------------------ >8 ------------------------"
+
+# The characters ``core.commentChar = auto`` chooses from, in git's order.
+_AUTO_COMMENT_CHARS = "#;@!$%^&|:"
+
+
+def _comment_char(lines: list[str]) -> str:
+    """The comment character git used when it wrote these message lines.
+
+    ``core.commentChar`` names it, ``#`` when unset. ``auto`` lets git pick
+    a character no line of the message starts with, and the file does not
+    say which: its scissors line names it when there is one, and otherwise
+    the comment block git appends ends the file, so the last non-blank line
+    names it if it starts with one of the characters git picks from.
+    """
+    configured = get_git_config_value("core.commentChar")
+    if configured != "auto":
+        return configured or "#"
+    for line in lines:
+        if line[:1] in _AUTO_COMMENT_CHARS and line[1:] == f" {SCISSORS_LINE}":
+            return line[0]
+    last = next((line for line in reversed(lines) if line.strip()), "")
+    return last[0] if last[:1] in _AUTO_COMMENT_CHARS else "#"
+
+
+def split_message_comments(text: str) -> tuple[str, str]:
+    """Split a commit message file into the message git will store and the rest.
+
+    git runs the commit-msg hook before it cleans the message, so the file
+    still holds the comment block written for the editor and, under ``git
+    commit -v``, a scissors line followed by the whole diff. Checking that as
+    the message lets a comment satisfy ``require_body`` and a sign-off in the
+    diff satisfy ``require_signed_off_by``. The message is what git's default
+    cleanup leaves: everything from the scissors line on goes, every line
+    that starts with the comment character goes, and so do the blank lines
+    left at the end. The rest is those comment lines and the scissors block,
+    in order, for a caller that writes the file back.
+    """
+    lines = text.split("\n")
+    if lines[-1] == "":
+        lines.pop()
+    tail: list[str] = []
+    # A message with no line that starts with punctuation holds nothing git
+    # strips, whatever the comment character (git's are punctuation), so the
+    # git call is skipped. That covers a file written by ``git commit -m``.
+    if not any(
+        line[:1] and not (line[0].isalnum() or line[0].isspace()) for line in lines
+    ):
+        while lines and not lines[-1].strip():
+            lines.pop()
+        return "\n".join(lines), ""
+    comment = _comment_char(lines)
+    scissors = f"{comment} {SCISSORS_LINE}"
+    if scissors in lines:
+        cut = lines.index(scissors)
+        lines, tail = lines[:cut], lines[cut:]
+    kept = [line for line in lines if not line.startswith(comment)]
+    while kept and not kept[-1].strip():
+        kept.pop()
+    rest = [line for line in lines if line.startswith(comment)] + tail
+    return "\n".join(kept), "".join(f"{line}\n" for line in rest)
+
+
+def read_commit_message_file(path: str) -> str:
+    """Read a commit message file and return the message git will store.
+
+    See :func:`split_message_comments`. Errors from opening the file are
+    left to the caller.
+    """
+    with open(path, encoding="utf-8") as f:
+        return split_message_comments(f.read())[0]
+
+
 def get_git_user_identity() -> tuple[str, str]:
     """The configured ``user.name`` and ``user.email``, in one git call.
 

{commit_check-2.19.0.dist-info → commit_check-2.19.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commit-check
-Version: 2.19.0
+Version: 2.19.2
 Summary: Commit policy as code for teams and AI agents: check commit messages, branch names, authors, tags, files and AI attribution.
 Author-email: Xianpeng Shen <xianpeng.shen@gmail.com>
 License-Expression: MIT
@@ -47,7 +47,7 @@ Dynamic: license-file
 
 [![PyPI](https://img.shields.io/pypi/v/commit-check?labelColor=0b1620&logo=pypi&logoColor=white&color=2c9ccd)](https://pypi.org/project/commit-check/)
 [![Downloads](https://img.shields.io/pepy/dt/commit-check?labelColor=0b1620&color=2c9ccd)](https://pepy.tech/projects/commit-check)
-[![CI](https://img.shields.io/github/actions/workflow/status/commit-check/commit-check/main.yml?branch=main&labelColor=0b1620&label=CI)](https://github.com/commit-check/commit-check/actions/workflows/main.yml)
+[![CI](https://img.shields.io/github/actions/workflow/status/commit-check/commit-check/ci.yml?branch=main&labelColor=0b1620&label=CI)](https://github.com/commit-check/commit-check/actions/workflows/ci.yml)
 [![Coverage](https://img.shields.io/codecov/c/github/commit-check/commit-check?labelColor=0b1620&color=2c9ccd&label=coverage)](https://codecov.io/gh/commit-check/commit-check)
 [![OpenSSF Scorecard](https://img.shields.io/ossf-scorecard/github.com/commit-check/commit-check?labelColor=0b1620&color=2c9ccd&label=OpenSSF%20Scorecard)](https://scorecard.dev/viewer/?uri=github.com/commit-check/commit-check)
 
@@ -159,7 +159,7 @@ Priority: CLI > env > TOML > default. Booleans accept `true/false`, `yes/no`,
 | `commit.allow_merge_commits` | `true` | `--allow-merge-commits` | `CCHK_ALLOW_MERGE_COMMITS` | Allow merge commits (CC006) |
 | `commit.allow_revert_commits` | `true` | `--allow-revert-commits` | `CCHK_ALLOW_REVERT_COMMITS` | Allow revert commits (CC007) |
 | `commit.allow_empty_commits` | `true` | `--allow-empty-commits` | `CCHK_ALLOW_EMPTY_COMMITS` | Allow empty commit messages (CC008) |
-| `commit.allow_fixup_commits` | `true` | `--allow-fixup-commits` | `CCHK_ALLOW_FIXUP_COMMITS` | Allow `fixup!` commits (CC009) |
+| `commit.allow_fixup_commits` | `true` | `--allow-fixup-commits` | `CCHK_ALLOW_FIXUP_COMMITS` | Allow `fixup!`, `squash!` and `amend!` commits (CC009) |
 | `commit.allow_wip_commits` | `true` | `--allow-wip-commits` | `CCHK_ALLOW_WIP_COMMITS` | Allow WIP commits (CC010) |
 | `commit.require_body` | `false` | `--require-body` | `CCHK_REQUIRE_BODY` | Require a commit body (CC011) |
 | `commit.require_signed_off_by` | `false` | `--require-signed-off-by` | `CCHK_REQUIRE_SIGNED_OFF_BY` | Require a `Signed-off-by:` trailer (CC012) |
@@ -172,7 +172,7 @@ Priority: CLI > env > TOML > default. Booleans accept `true/false`, `yes/no`,
 | `branch.conventional_branch` | `true` | `--conventional-branch` | `CCHK_CONVENTIONAL_BRANCH` | Enforce `<type>/<description>` branch names (CC201) |
 | `branch.require_description_grammar` | `false` | `--require-description-grammar` | `CCHK_REQUIRE_DESCRIPTION_GRAMMAR` | Also hold the description after `<type>/` to the Conventional Branch grammar: lowercase alphanumeric words joined by single hyphens, dots allowed inside a word (CC201). Off by default, since bot branches such as `dependabot/npm_and_yarn/lodash-4.17.21` do not follow it |
 | `branch.allow_branch_types` | `feature, bugfix, hotfix, release, chore, feat, fix, build, ci, docs, perf, refactor, test, style, ai, claude, codex, copilot, cursor, dependabot, renovate` | `--allow-branch-types` | `CCHK_ALLOW_BRANCH_TYPES` | Allowed branch `<type>` prefixes; each entry is a regex matched against the whole type |
-| `branch.allow_branch_names` | `[]` | `--allow-branch-names` | `CCHK_ALLOW_BRANCH_NAMES` | Extra branch names allowed besides `main`, `master`, `HEAD`, `PR-.+`; each entry is a regex matched against the whole branch name, so `create-pull-request/.+` allows a family of them |
+| `branch.allow_branch_names` | `[]` | `--allow-branch-names` | `CCHK_ALLOW_BRANCH_NAMES` | Extra branch names allowed besides `main`, `master`, `develop`, `HEAD`, `PR-.+`; each entry is a regex matched against the whole branch name, so `create-pull-request/.+` allows a family of them |
 | `branch.require_rebase_target` | `""` | `--require-rebase-target` | `CCHK_REQUIRE_REBASE_TARGET` | Branch the current branch must be rebased onto (CC202); empty disables |
 | `branch.ignore_authors` | `[]` | `--branch-ignore-authors` | `CCHK_BRANCH_IGNORE_AUTHORS` | Authors whose branches skip the branch checks |
 | `push.allow_force_push` | `true` | — (`--no-force-push` runs the check) | `CCHK_ALLOW_FORCE_PUSH` | Reserved; has no effect today. CC301 runs only with `--no-force-push`, which always rejects a non-fast-forward push |

commit_check-2.19.2.dist-info/RECORD

@@ -0,0 +1,21 @@
+commit_check/__init__.py,sha256=wHIreV-DEKM5AiobnjfvxIuvIQ2DShRxc5SwSx50oX4,5232
+commit_check/ai_policy.py,sha256=gYC3ROLgGL1TDyhPkFXkV-NiYbvMt80Qt0MFrJcbJY4,8131
+commit_check/ai_signatures.py,sha256=0HTZy4othuwKVqfGZ2J7PaIMUPmQArhEQa0k7zGnCzs,10251
+commit_check/ai_signatures_data.py,sha256=2xWH8M3HoFlUh7n766GK4ahkKJi8_FvcTTOuYv_yWls,14314
+commit_check/api.py,sha256=07bvBtV8PrhZIOwCDHiHfu_7CXsX_4U2_K2xMAucd6c,12905
+commit_check/config.py,sha256=SB8Zvcll-kFOZgQ-olzYLv9CLJqaYIaCb37bcrjVNOE,14068
+commit_check/config_merger.py,sha256=umsjoTcWG7WXufxn7dIMlHrek0a8VWmqjynJR-A4LYQ,13406
+commit_check/engine.py,sha256=rot2jQ9rc8h3-pERCRR7GHsZt62BHtbDVThjHLUwZ7k,74064
+commit_check/fixes.py,sha256=BpbdoHsKDyw2WfsqymwYpnrW73aHdCDGr8tMF6Ho2RU,7305
+commit_check/imperatives.py,sha256=dEd_ssu4G0j6Cann6jqPdB97lw5Adua43K0_Odg_FyA,9518
+commit_check/main.py,sha256=LR3uyJXXHHLsVS90pshHbB7FfyTiUr-OmecI8wwvgEo,28157
+commit_check/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commit_check/rule_builder.py,sha256=YDa3re0-gNTKEBBOvnF_K8kP8MpFo9UC_l9eC_punsw,33435
+commit_check/rules_catalog.py,sha256=-C3Jo721vXRrY7-LzJs9iNF3ffXKEFldDfmBoLtujt4,11920
+commit_check/util.py,sha256=Q9nI_0yYu6WEJLD55vMnFozWhZzfP2Z4xrElecmqZBQ,32755
+commit_check-2.19.2.dist-info/licenses/LICENSE,sha256=9mdTva71kQhrpWh_nZulxrdCnUrl5c6xJYh5hdo4p_s,1070
+commit_check-2.19.2.dist-info/METADATA,sha256=ArwljHXzZqWZE2oKS5aSfoosL9b5RrPG49bS-MIsRyg,15971
+commit_check-2.19.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+commit_check-2.19.2.dist-info/entry_points.txt,sha256=YMrkFGeub-3-IanV1d9qnopXVaRQM7MA9foXKW9iZ88,86
+commit_check-2.19.2.dist-info/top_level.txt,sha256=Wf46u-ooHBMJNHbhfrBNQw3wC5_m8wt-o_Lfbc4QpRg,13
+commit_check-2.19.2.dist-info/RECORD,,

{commit_check-2.19.0.dist-info → commit_check-2.19.2.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 shenxianpeng (xianpeng.shen@gmail.com)
+Copyright (c) 2022 Xianpeng Shen
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

commit_check-2.19.0.dist-info/RECORD

@@ -1,21 +0,0 @@
-commit_check/__init__.py,sha256=QTpfP0b6G9TNS4McgunE6Oozwt3CkUaN4xkqEaR4570,4390
-commit_check/ai_policy.py,sha256=gYC3ROLgGL1TDyhPkFXkV-NiYbvMt80Qt0MFrJcbJY4,8131
-commit_check/ai_signatures.py,sha256=sPef5yb9KZ1FxN19XjLTAM2rzb4YdOSktF8HYUnzh5I,9662
-commit_check/ai_signatures_data.py,sha256=3WZIV1fibvr9f1s7MGSA-mNt_na2t11GIgVeS7Uw8Wc,13125
-commit_check/api.py,sha256=07bvBtV8PrhZIOwCDHiHfu_7CXsX_4U2_K2xMAucd6c,12905
-commit_check/config.py,sha256=Cy7DMWKrWbmVmYER1lUlpvFf9eHn5SfVUVWZ4zgit2w,9820
-commit_check/config_merger.py,sha256=umsjoTcWG7WXufxn7dIMlHrek0a8VWmqjynJR-A4LYQ,13406
-commit_check/engine.py,sha256=BEjQ-70SV5j3a0WvLyjEWwpUXUsVIFYynBMWK_dwWs4,71662
-commit_check/fixes.py,sha256=AsE9ChMXoOCV61pgxbZZNkAzmQS9_ARTWvvox4HkgEg,7088
-commit_check/imperatives.py,sha256=dEd_ssu4G0j6Cann6jqPdB97lw5Adua43K0_Odg_FyA,9518
-commit_check/main.py,sha256=14DkzTVO3dXgzMH0ZyEUob1fuPN8lBJiKJfnvlJx9Dg,27564
-commit_check/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-commit_check/rule_builder.py,sha256=LU619d0Ndd76oiiszQ07ZHuZ1V-wKQRnUJBP35SiPHE,30351
-commit_check/rules_catalog.py,sha256=JspIhkGXUviLkMG4HhH_IK2x5YTfX3t1p9gI7PbFD7Q,11558
-commit_check/util.py,sha256=XRt9xc6yLjIYY0xwpcZZOAWLc1dL_MPiJNu-64Fi7jk,27810
-commit_check-2.19.0.dist-info/licenses/LICENSE,sha256=VAJ9TE1ov8aUKmeoBRYqciMs0CXag1TeDCoLhwbeQmA,1095
-commit_check-2.19.0.dist-info/METADATA,sha256=0vshw4iiOm7lPfdNUmgwrhMqLv2AIO7_i27AFW9sJIA,15940
-commit_check-2.19.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-commit_check-2.19.0.dist-info/entry_points.txt,sha256=YMrkFGeub-3-IanV1d9qnopXVaRQM7MA9foXKW9iZ88,86
-commit_check-2.19.0.dist-info/top_level.txt,sha256=Wf46u-ooHBMJNHbhfrBNQw3wC5_m8wt-o_Lfbc4QpRg,13
-commit_check-2.19.0.dist-info/RECORD,,