glab-release-notes 0.1.0__py3-none-any.whl

glab_release_notes/__init__.py

@@ -0,0 +1,32 @@
+"""Release notes for GitLab projects, generated from merged merge requests."""
+
+from glab_release_notes.config import NotesConfig, default_config, load_config
+from glab_release_notes.edit import append_note, promote_notes
+from glab_release_notes.models import LabelDecision, MergeRequest, ReleaseNotesError
+from glab_release_notes.parse import (
+    already_recorded,
+    classify,
+    parse_quote,
+    parse_ticket,
+    validate_record,
+)
+from glab_release_notes.payload import merge_request_from_payload
+from glab_release_notes.render import format_entry
+
+__all__ = (
+    "LabelDecision",
+    "MergeRequest",
+    "NotesConfig",
+    "ReleaseNotesError",
+    "already_recorded",
+    "append_note",
+    "classify",
+    "default_config",
+    "format_entry",
+    "load_config",
+    "merge_request_from_payload",
+    "parse_quote",
+    "parse_ticket",
+    "promote_notes",
+    "validate_record",
+)

glab_release_notes/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point: ``python -m glab_release_notes``."""
+
+from glab_release_notes.cli import main
+
+if __name__ == "__main__":
+    main()

glab_release_notes/api.py

@@ -0,0 +1,40 @@
+"""Fetch merge requests from the GitLab API."""
+
+from urllib.parse import quote
+
+from glab_release_notes.http import Payload, gitlab_json, payload_list
+from glab_release_notes.models import MergeRequest, ReleaseNotesError
+from glab_release_notes.payload import merge_request_from_payload
+
+
+def fetch_mr(iid: int) -> MergeRequest:
+    """Load a merge request by iid."""
+    raw = gitlab_json(f"merge_requests/{iid}")
+    if not isinstance(raw, dict):
+        msg = f"Invalid GitLab response for MR !{iid}"
+        raise ReleaseNotesError(msg)
+    return merge_request_from_payload(raw)
+
+
+def _first_or_none(payloads: list[Payload]) -> Payload | None:
+    if payloads:
+        return payloads[0]
+    return None
+
+
+def _pick_payload(payloads: list[Payload]) -> Payload | None:
+    merged = [payload for payload in payloads if payload.get("state") == "merged"]
+    chosen = _first_or_none(merged)
+    if chosen is not None:
+        return chosen
+    return _first_or_none(payloads)
+
+
+def fetch_mr_for_commit(sha: str) -> MergeRequest | None:
+    """Find the merged merge request for a commit SHA."""
+    encoded = quote(sha, safe="")
+    path = f"repository/commits/{encoded}/merge_requests"
+    chosen = _pick_payload(payload_list(gitlab_json(path)))
+    if chosen is None:
+        return None
+    return merge_request_from_payload(chosen)

glab_release_notes/append_cmd.py

@@ -0,0 +1,81 @@
+"""The append command: record a merged merge request."""
+
+import logging
+from pathlib import Path
+
+from glab_release_notes import constants
+from glab_release_notes.config import NotesConfig
+from glab_release_notes.edit import AppendMutator
+from glab_release_notes.gitops import push_notes
+from glab_release_notes.load import load_mr_for_append
+from glab_release_notes.models import Classification, LabelDecision, MergeRequest, ReleaseNotesError
+from glab_release_notes.parse import (
+    already_recorded,
+    classify,
+    parse_quote,
+    parse_ticket,
+    validate_record,
+)
+from glab_release_notes.render import format_entry
+
+logger = logging.getLogger(__name__)
+
+
+def _build_entry(
+    merge_request: MergeRequest,
+    classification: Classification,
+    *,
+    cfg: NotesConfig,
+    jira_base: str | None,
+) -> tuple[str, str]:
+    validate_record(labels=merge_request.labels, description=merge_request.description, cfg=cfg)
+    if classification.spec is None:
+        msg = "No section after a successful validation"
+        raise ReleaseNotesError(msg)
+    quote = parse_quote(merge_request.description)
+    if quote is None:
+        msg = "No entry text"
+        raise ReleaseNotesError(msg)
+    entry = format_entry(
+        text=quote,
+        spec=classification.spec,
+        mr=merge_request,
+        ticket=parse_ticket(merge_request.source_branch),
+        jira_base=jira_base,
+    )
+    return entry, classification.spec.header
+
+
+def _is_skipped(
+    merge_request: MergeRequest,
+    notes_path: Path,
+    classification: Classification,
+) -> bool:
+    if merge_request.state and merge_request.state != "merged":
+        logger.info("MR !%s is in state %s, skipping", merge_request.iid, merge_request.state)
+        return True
+    if classification.decision is LabelDecision.SKIP:
+        logger.info("Skip label on MR !%s, skipping", merge_request.iid)
+        return True
+    notes_markdown = notes_path.read_text(encoding=constants.encoding)
+    if already_recorded(notes_markdown, merge_request.iid):
+        logger.info("MR !%s is already recorded, skipping", merge_request.iid)
+        return True
+    return False
+
+
+def cmd_append(*, notes_path: Path, cfg: NotesConfig, jira_base: str | None = None) -> None:
+    """Record a merged merge request and push the commit."""
+    merge_request = load_mr_for_append()
+    if merge_request is None:
+        logger.info("No merge request found, skipping")
+        return
+    classification = classify(merge_request.labels, cfg)
+    if _is_skipped(merge_request, notes_path, classification):
+        return
+    entry, header = _build_entry(merge_request, classification, cfg=cfg, jira_base=jira_base)
+    push_notes(
+        notes_path,
+        f"chore(notes): add entry for MR !{merge_request.iid}",
+        AppendMutator(entry, header, merge_request.iid, cfg=cfg),
+    )

glab_release_notes/cli.py

@@ -0,0 +1,104 @@
+"""CLI commands: validate, append, promote."""
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from glab_release_notes import constants
+from glab_release_notes.append_cmd import cmd_append
+from glab_release_notes.config import NotesConfig, load_config
+from glab_release_notes.edit import PromoteMutator, promote_notes
+from glab_release_notes.gitops import push_notes
+from glab_release_notes.load import load_mr_for_validate
+from glab_release_notes.models import ReleaseNotesError
+from glab_release_notes.parse import validate_record
+
+logger = logging.getLogger(__name__)
+
+
+def cmd_validate(cfg: NotesConfig) -> None:
+    """Validate the labels and quote of the current merge request."""
+    merge_request = load_mr_for_validate()
+    validate_record(labels=merge_request.labels, description=merge_request.description, cfg=cfg)
+    logger.info("Release notes validation passed for MR !%s", merge_request.iid)
+
+
+def _write_promoted(notes_path: Path, version: str, cfg: NotesConfig) -> None:
+    current = notes_path.read_text(encoding=constants.encoding)
+    updated = promote_notes(current, version, cfg)
+    if updated == current:
+        logger.info("Nothing to change, skipping")
+        return
+    notes_path.write_text(updated, encoding=constants.encoding)
+
+
+def cmd_promote(*, notes_path: Path, cfg: NotesConfig, version: str, push: bool = True) -> None:
+    """Promote the unreleased block under a version heading.
+
+    With ``push=False`` the file is rewritten in place only; the release
+    process owns the commit.
+    """
+    if not push:
+        _write_promoted(notes_path, version, cfg)
+        return
+    message = f"chore(notes): promote {version}"
+    push_notes(notes_path, message, PromoteMutator(version, cfg))
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Maintain release notes from merged GitLab MRs")
+    parser.add_argument(
+        "--config",
+        default=None,
+        metavar="PATH",
+        help="TOML config file; defaults to release-notes.toml in the current directory",
+    )
+    parser.add_argument(
+        "--file",
+        default=None,
+        metavar="PATH",
+        help="Path to the notes file; overrides 'file' from the config",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    subparsers.add_parser("validate", help="Validate the current merge request")
+    append = subparsers.add_parser("append", help="Append an entry after a merge")
+    append.add_argument(
+        "--jira-base",
+        default=None,
+        help="Base URL of Jira, e.g. https://jira.mwnts.net/browse; no link without it",
+    )
+    promote = subparsers.add_parser("promote", help="Move unreleased entries under a version")
+    promote.add_argument("--version", required=True, help="Version, e.g. 0.8.2")
+    promote.add_argument(
+        "--no-push",
+        action="store_true",
+        help="Rewrite the file only, without a commit and push",
+    )
+    return parser
+
+
+def _dispatch(
+    command: str, notes_path: Path, args: argparse.Namespace, *, cfg: NotesConfig
+) -> None:
+    if command == "validate":
+        cmd_validate(cfg)
+        return
+    if command == "append":
+        cmd_append(notes_path=notes_path, cfg=cfg, jira_base=args.jira_base)
+        return
+    if command == "promote":
+        cmd_promote(notes_path=notes_path, cfg=cfg, version=args.version, push=not args.no_push)
+
+
+def main(argv: list[str] | None = None) -> None:
+    """Entry point for the CLI."""
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
+    args = _build_parser().parse_args(argv)
+    cfg = load_config(args.config)
+    notes_path = Path(args.file) if args.file else cfg.notes_file
+    try:
+        _dispatch(args.command, notes_path, args, cfg=cfg)
+    except ReleaseNotesError:
+        logger.exception("Failed to update release notes")
+        sys.exit(1)

glab_release_notes/config.py

@@ -0,0 +1,178 @@
+"""Configuration for release note generation."""
+
+import tomllib
+from collections.abc import Mapping
+from dataclasses import dataclass
+from pathlib import Path
+from types import MappingProxyType
+
+from glab_release_notes.models import ReleaseNotesError, SectionSpec
+
+#: The config file looked up in the current directory by default.
+DEFAULT_CONFIG_FILE = "release-notes.toml"
+
+_DEFAULT_NOTES_FILE = "docs/release-notes.md"
+_DEFAULT_UNRELEASED_HEADER = "## Latest Changes"
+_DEFAULT_SECTION_PREFIX = "### "
+_DEFAULT_SKIP_LABELS = ("release", "refactor", "test", "chore", "style")
+_DEFAULT_ALWAYS_KEEP = ("Features", "Fixes")
+_DEFAULT_SECTIONS = (
+    SectionSpec("feature", "Features", "✨", "feat"),
+    SectionSpec("bug", "Fixes", "🐛", "fix"),
+    SectionSpec("docs", "Documentation", "📝", "docs"),
+    SectionSpec("ci", "CI", "👷", "ci"),
+)
+
+_TOP_LEVEL_KEYS = (
+    "file",
+    "unreleased_header",
+    "section_prefix",
+    "skip_labels",
+    "always_keep",
+    "section",
+)
+_SECTION_KEYS = ("label", "header", "emoji", "anchor_prefix")
+
+
+@dataclass(frozen=True, slots=True)
+class NotesConfig:
+    """The configurable text of the release notes."""
+
+    notes_file: Path
+    unreleased_header: str
+    section_prefix: str
+    skip_labels: frozenset[str]
+    always_keep: tuple[str, ...]
+    sections: tuple[SectionSpec, ...]
+
+    @property
+    def section_order(self) -> tuple[str, ...]:
+        """Section headers in display order."""
+        return tuple(spec.header for spec in self.sections)
+
+    @property
+    def by_header(self) -> Mapping[str, SectionSpec]:
+        """Sections indexed by header."""
+        return MappingProxyType({spec.header: spec for spec in self.sections})
+
+    @property
+    def by_label(self) -> Mapping[str, SectionSpec]:
+        """Sections indexed by label."""
+        return MappingProxyType({spec.label: spec for spec in self.sections})
+
+
+def default_config() -> NotesConfig:
+    """The built-in defaults (the team convention)."""
+    return NotesConfig(
+        notes_file=Path(_DEFAULT_NOTES_FILE),
+        unreleased_header=_DEFAULT_UNRELEASED_HEADER,
+        section_prefix=_DEFAULT_SECTION_PREFIX,
+        skip_labels=frozenset(_DEFAULT_SKIP_LABELS),
+        always_keep=_DEFAULT_ALWAYS_KEEP,
+        sections=_DEFAULT_SECTIONS,
+    )
+
+
+def load_config(path: str | Path | None = None) -> NotesConfig:
+    """Load the config from a TOML file, or from the built-in defaults.
+
+    An explicit ``path`` must exist. Without one, ``release-notes.toml`` from the
+    current directory is used if present.
+    """
+    if path is not None:
+        config_path = Path(path)
+        if not config_path.is_file():
+            msg = f"Config file not found: {config_path}"
+            raise ReleaseNotesError(msg)
+        return _config_from_data(_read_toml(config_path))
+    config_path = Path(DEFAULT_CONFIG_FILE)
+    if config_path.is_file():
+        return _config_from_data(_read_toml(config_path))
+    return default_config()
+
+
+def _read_toml(config_path: Path) -> dict[str, object]:
+    try:
+        with config_path.open("rb") as handle:
+            data = tomllib.load(handle)
+    except tomllib.TOMLDecodeError as exc:
+        msg = f"Invalid TOML in {config_path}: {exc}"
+        raise ReleaseNotesError(msg) from exc
+    return data
+
+
+def _config_from_data(data: dict[str, object]) -> NotesConfig:
+    unknown = sorted(set(data) - set(_TOP_LEVEL_KEYS))
+    if unknown:
+        msg = f"Unknown config keys: {', '.join(unknown)}"
+        raise ReleaseNotesError(msg)
+
+    sections = _parse_sections(data.get("section"))
+    always_keep = _str_list(data.get("always_keep", list(_DEFAULT_ALWAYS_KEEP)), "always_keep")
+    skip_labels = _str_list(data.get("skip_labels", list(_DEFAULT_SKIP_LABELS)), "skip_labels")
+    known_headers = {spec.header for spec in sections}
+    unknown_kept = [header for header in always_keep if header not in known_headers]
+    if unknown_kept:
+        msg = f"always_keep references unknown sections: {', '.join(unknown_kept)}"
+        raise ReleaseNotesError(msg)
+
+    return NotesConfig(
+        notes_file=Path(str(data.get("file", _DEFAULT_NOTES_FILE))),
+        unreleased_header=str(data.get("unreleased_header", _DEFAULT_UNRELEASED_HEADER)),
+        section_prefix=str(data.get("section_prefix", _DEFAULT_SECTION_PREFIX)),
+        skip_labels=frozenset(skip_labels),
+        always_keep=tuple(always_keep),
+        sections=sections,
+    )
+
+
+def _parse_sections(raw: object) -> tuple[SectionSpec, ...]:
+    if not isinstance(raw, list) or not raw:
+        msg = "At least one [[section]] is required"
+        raise ReleaseNotesError(msg)
+    sections: list[SectionSpec] = []
+    seen: set[str] = set()
+    for index, entry in enumerate(raw):
+        spec = _parse_section(entry, index)
+        if spec.label in seen:
+            msg = f"Duplicate section label: {spec.label}"
+            raise ReleaseNotesError(msg)
+        seen.add(spec.label)
+        sections.append(spec)
+    return tuple(sections)
+
+
+def _parse_section(entry: object, index: int) -> SectionSpec:
+    if not isinstance(entry, dict):
+        msg = f"[[section]] #{index + 1} must be a table"
+        raise ReleaseNotesError(msg)
+    unknown = sorted(set(entry) - set(_SECTION_KEYS))
+    if unknown:
+        msg = f"[[section]] #{index + 1}: unknown keys {', '.join(unknown)}"
+        raise ReleaseNotesError(msg)
+    label = _required_str(entry, "label", index)
+    header = _required_str(entry, "header", index)
+    emoji = entry.get("emoji", "")
+    if not isinstance(emoji, str):
+        msg = f"[[section]] #{index + 1}: 'emoji' must be a string"
+        raise ReleaseNotesError(msg)
+    anchor = _required_str(entry, "anchor_prefix", index, default=label)
+    return SectionSpec(label=label, header=header, emoji=emoji, anchor_prefix=anchor)
+
+
+def _required_str(
+    entry: dict[str, object], key: str, index: int, *, default: str | None = None
+) -> str:
+    value = entry.get(key, default)
+    if not isinstance(value, str) or not value:
+        required = "' is required" if default is None else "' must be a non-empty string"
+        msg = f"[[section]] #{index + 1}: '{key}{required}"
+        raise ReleaseNotesError(msg)
+    return value
+
+
+def _str_list(raw: object, name: str) -> list[str]:
+    if not isinstance(raw, list) or not all(isinstance(item, str) for item in raw):
+        msg = f"'{name}' must be a list of strings"
+        raise ReleaseNotesError(msg)
+    return raw

glab_release_notes/constants.py

@@ -0,0 +1,15 @@
+"""Format constants for the release notes (regexes and tool settings)."""
+
+import re
+
+push_retries = 10
+http_timeout = 30
+double_newline = "\n\n"
+encoding = "utf-8"
+git_bin = "git"
+
+quote_re = re.compile(r"^> ?(.*\S.*)$", re.MULTILINE)
+ticket_re = re.compile(r"(?i)\b([a-z]{2,})[-_](\d+)\b")
+version_line_re = re.compile(r"^## ", re.MULTILINE)
+anchor_re = re.compile(r"\s*\{#.*\}\s*$")
+item_re = re.compile(r"^\* ", re.MULTILINE)

glab_release_notes/edit.py

@@ -0,0 +1,87 @@
+"""Insert an entry and promote unreleased entries under a version."""
+
+from glab_release_notes import constants
+from glab_release_notes.config import NotesConfig
+from glab_release_notes.parse import already_recorded
+from glab_release_notes.render import assemble, prepend_entry, render_unreleased
+from glab_release_notes.split import parse_sections, split_unreleased
+
+
+def has_items(body: str) -> bool:
+    """Whether a section has any list items."""
+    return constants.item_re.search(body) is not None
+
+
+def append_note(notes_markdown: str, entry: str, header: str, *, cfg: NotesConfig) -> str:
+    """Insert an entry into the right section of the unreleased block."""
+    prefix, unreleased, postfix = split_unreleased(notes_markdown, cfg)
+    sections = prepend_entry(parse_sections(unreleased, cfg), header, entry)
+    return assemble(prefix, render_unreleased(sections, cfg), postfix)
+
+
+def _version_blocks(sections: dict[str, str], version: str, cfg: NotesConfig) -> list[str]:
+    blocks: list[str] = []
+    for header in cfg.section_order:
+        body = sections.get(header, "")
+        if not has_items(body):
+            continue
+        spec = cfg.by_header[header]
+        title = f"{cfg.section_prefix}{header} {{#{spec.anchor_prefix}_{version}}}"
+        blocks.append(f"{title}{constants.double_newline}{body}")
+    return blocks
+
+
+def _assemble_promoted(
+    *,
+    prefix: str,
+    postfix: str,
+    version: str,
+    blocks: list[str],
+    cfg: NotesConfig,
+) -> str:
+    emptied: dict[str, str] = dict.fromkeys(cfg.always_keep, "")
+    joined = constants.double_newline.join(blocks)
+    heading = f"## {version}{constants.double_newline}{joined}"
+    new_post = f"{heading}{constants.double_newline}{postfix.strip()}"
+    return assemble(prefix, render_unreleased(emptied, cfg), new_post.strip())
+
+
+def promote_notes(notes_markdown: str, version: str, cfg: NotesConfig) -> str:
+    """Move non-empty unreleased sections under a version heading."""
+    prefix, unreleased, postfix = split_unreleased(notes_markdown, cfg)
+    blocks = _version_blocks(parse_sections(unreleased, cfg), version, cfg)
+    if not blocks:
+        return notes_markdown
+    return _assemble_promoted(
+        prefix=prefix, postfix=postfix, version=version, blocks=blocks, cfg=cfg
+    )
+
+
+class AppendMutator:
+    """Re-inserts the entry after a git pull."""
+
+    def __init__(self, entry: str, header: str, iid: int, *, cfg: NotesConfig) -> None:
+        """Keep the entry text, the section, the MR iid, and the config."""
+        self._entry = entry
+        self._header = header
+        self._iid = iid
+        self._cfg = cfg
+
+    def __call__(self, notes_markdown: str) -> str:
+        """Return the markdown with the entry, if not already present."""
+        if already_recorded(notes_markdown, self._iid):
+            return notes_markdown
+        return append_note(notes_markdown, self._entry, self._header, cfg=self._cfg)
+
+
+class PromoteMutator:
+    """Re-promotes the unreleased block after a git pull."""
+
+    def __init__(self, version: str, cfg: NotesConfig) -> None:
+        """Keep the version number and the config."""
+        self._version = version
+        self._cfg = cfg
+
+    def __call__(self, notes_markdown: str) -> str:
+        """Return the markdown with the promoted entries."""
+        return promote_notes(notes_markdown, self._version, self._cfg)

glab_release_notes/gitops.py

@@ -0,0 +1,56 @@
+"""Commit and push the updated release notes."""
+
+import logging
+import subprocess
+from collections.abc import Callable
+from pathlib import Path
+
+from glab_release_notes import constants
+from glab_release_notes.models import ReleaseNotesError
+
+logger = logging.getLogger(__name__)
+
+
+def _run_git(args: list[str], *, check: bool) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(args, check=check, text=True)  # noqa: S603
+
+
+def _commit_notes(path: Path, message: str, updated: str) -> subprocess.CompletedProcess[str]:
+    encoding = constants.encoding
+    git = constants.git_bin
+    path.write_text(updated, encoding=encoding)
+    _run_git([git, "add", str(path)], check=True)
+    _run_git([git, "commit", "-m", message], check=True)
+    return _run_git([git, "push"], check=False)
+
+
+def _reset_notes(path: Path) -> None:
+    git = constants.git_bin
+    _run_git([git, "reset", "HEAD^"], check=True)
+    _run_git([git, "checkout", "--", str(path)], check=True)
+
+
+def _try_push(path: Path, message: str, mutate: Callable[[str], str]) -> bool:
+    git = constants.git_bin
+    encoding = constants.encoding
+    _run_git([git, "pull", "--rebase"], check=False)
+    current = path.read_text(encoding=encoding)
+    updated = mutate(current)
+    if updated == current:
+        logger.info("Nothing to change, skipping")
+        return True
+    pushed = _commit_notes(path, message, updated)
+    if pushed.returncode == 0:
+        return True
+    _reset_notes(path)
+    return False
+
+
+def push_notes(path: Path, message: str, mutate: Callable[[str], str]) -> None:
+    """Commit the notes, retrying on a push race."""
+    for trial in range(constants.push_retries):
+        logger.info("Push attempt %s/%s", trial + 1, constants.push_retries)
+        if _try_push(path, message, mutate):
+            return
+    msg = f"Could not push the notes after {constants.push_retries} attempts"
+    raise ReleaseNotesError(msg)

glab_release_notes/http.py

@@ -0,0 +1,39 @@
+"""Low-level HTTP client for the GitLab API."""
+
+import json
+import os
+from urllib.error import HTTPError
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+
+from glab_release_notes import constants
+from glab_release_notes.models import ReleaseNotesError
+
+type Payload = dict[str, object]
+
+
+def api_url(path: str) -> str:
+    """Build a GitLab API URL for the current project."""
+    base = os.environ["CI_API_V4_URL"].rstrip("/")
+    project = quote(str(os.environ["CI_PROJECT_ID"]), safe="")
+    return f"{base}/projects/{project}/{path}"
+
+
+def gitlab_json(path: str) -> object:
+    """GET JSON with the CI job token."""
+    url = api_url(path)
+    headers = {"PRIVATE-TOKEN": os.environ["GITLAB_API_TOKEN"]}
+    http_request = Request(url, headers=headers)  # noqa: S310
+    try:
+        with urlopen(http_request, timeout=constants.http_timeout) as response:  # noqa: S310
+            return json.loads(response.read().decode())
+    except HTTPError as exc:
+        msg = f"GitLab API {url} -> HTTP {exc.code}"
+        raise ReleaseNotesError(msg) from exc
+
+
+def payload_list(raw: object) -> list[Payload]:
+    """Keep only dict objects from an API response."""
+    if not isinstance(raw, list):
+        return []
+    return [payload for payload in raw if isinstance(payload, dict)]

glab_release_notes/load.py

@@ -0,0 +1,30 @@
+"""Pick the merge request from CI variables."""
+
+import os
+
+from glab_release_notes.api import fetch_mr, fetch_mr_for_commit
+from glab_release_notes.models import MergeRequest, ReleaseNotesError
+
+
+def _env_value(name: str) -> str:
+    return os.environ.get(name, "").strip()
+
+
+def load_mr_for_validate() -> MergeRequest:
+    """MR for validation: iid from the merge request pipeline."""
+    iid = _env_value("CI_MERGE_REQUEST_IID")
+    if not iid:
+        msg = "CI_MERGE_REQUEST_IID is required"
+        raise ReleaseNotesError(msg)
+    return fetch_mr(int(iid))
+
+
+def load_mr_for_append() -> MergeRequest | None:
+    """MR for appending: manual MR_IID or the MR of the current commit."""
+    iid = _env_value("MR_IID")
+    if iid:
+        return fetch_mr(int(iid))
+    sha = _env_value("CI_COMMIT_SHA")
+    if not sha:
+        return None
+    return fetch_mr_for_commit(sha)

glab_release_notes/models.py

@@ -0,0 +1,48 @@
+"""Data models for release notes."""
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class LabelDecision(Enum):
+    """Result of analyzing a merge request's labels."""
+
+    SKIP = "skip"
+    MISSING = "missing"
+    SECTION = "section"
+
+
+class ReleaseNotesError(Exception):
+    """Error while validating or updating release notes."""
+
+
+@dataclass(frozen=True, slots=True)
+class SectionSpec:
+    """A GitLab label and its section header, emoji, and anchor prefix."""
+
+    label: str
+    header: str
+    emoji: str
+    anchor_prefix: str
+
+
+@dataclass(frozen=True, slots=True)
+class Classification:
+    """Classification of a merge request by its labels."""
+
+    decision: LabelDecision
+    spec: SectionSpec | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class MergeRequest:
+    """Merge request data needed to record an entry."""
+
+    iid: int
+    description: str
+    labels: tuple[str, ...]
+    web_url: str
+    author_username: str
+    author_url: str
+    source_branch: str
+    state: str

glab_release_notes/parse.py

@@ -0,0 +1,55 @@
+"""Parse the quote, ticket key, and labels of a merge request."""
+
+from glab_release_notes import constants
+from glab_release_notes.config import NotesConfig
+from glab_release_notes.models import Classification, LabelDecision, ReleaseNotesError
+
+
+def parse_quote(description: str) -> str | None:
+    """Return the last non-empty quote from the MR description."""
+    matches: list[str] = [line.strip() for line in constants.quote_re.findall(description)]
+    if not matches:
+        return None
+    return matches[-1]
+
+
+def parse_ticket(branch: str) -> str | None:
+    """Extract a Jira ticket key from a branch name."""
+    match = constants.ticket_re.search(branch)
+    if match is None:
+        return None
+    prefix = match.group(1).upper()
+    number = match.group(2)
+    return f"{prefix}-{number}"
+
+
+def classify(labels: tuple[str, ...], cfg: NotesConfig) -> Classification:
+    """Determine skip / missing / section from labels."""
+    label_set = set(labels)
+    if label_set & cfg.skip_labels:
+        return Classification(LabelDecision.SKIP)
+    for spec in cfg.sections:
+        if spec.label in label_set:
+            return Classification(LabelDecision.SECTION, spec)
+    return Classification(LabelDecision.MISSING)
+
+
+def validate_record(*, labels: tuple[str, ...], description: str, cfg: NotesConfig) -> None:
+    """Check that the MR is ready to be recorded in the release notes."""
+    classification = classify(labels, cfg)
+    if classification.decision is LabelDecision.SKIP:
+        return
+    if classification.decision is LabelDecision.MISSING:
+        section_labels = ", ".join(spec.label for spec in cfg.sections)
+        skip_labels = ", ".join(sorted(cfg.skip_labels))
+        msg = f"A section label ({section_labels}) or a skip label ({skip_labels}) is required"
+        raise ReleaseNotesError(msg)
+    if parse_quote(description) is None:
+        msg = "The MR description has no entry text (a `> …` quote)"
+        raise ReleaseNotesError(msg)
+
+
+def already_recorded(notes_markdown: str, iid: int) -> bool:
+    """Check whether a link to this MR is already present."""
+    marker = f"/merge_requests/{iid})"
+    return marker in notes_markdown

glab_release_notes/payload.py

@@ -0,0 +1,49 @@
+"""Parse GitLab API JSON into a MergeRequest."""
+
+from glab_release_notes.models import MergeRequest, ReleaseNotesError
+
+
+def _labels_from_string(raw: str) -> tuple[str, ...]:
+    parts = raw.split(",")
+    return tuple(part.strip() for part in parts if part.strip())
+
+
+def _labels_from_list(raw: list[object]) -> tuple[str, ...]:
+    return tuple(
+        raw_label.strip() for raw_label in raw if isinstance(raw_label, str) and raw_label.strip()
+    )
+
+
+def split_labels(raw: object) -> tuple[str, ...]:
+    """Normalize labels from a string or a list from the API."""
+    if isinstance(raw, str):
+        return _labels_from_string(raw)
+    if isinstance(raw, list):
+        return _labels_from_list(raw)
+    return ()
+
+
+def _author_map(payload: dict[str, object]) -> dict[str, object]:
+    author_obj = payload.get("author")
+    if isinstance(author_obj, dict):
+        return author_obj
+    return {}
+
+
+def merge_request_from_payload(payload: dict[str, object]) -> MergeRequest:
+    """Build a MergeRequest from GitLab API JSON."""
+    author = _author_map(payload)
+    iid_raw = payload.get("iid", payload.get("id"))
+    if not isinstance(iid_raw, int):
+        msg = "No MR iid in the GitLab response"
+        raise ReleaseNotesError(msg)
+    return MergeRequest(
+        iid=iid_raw,
+        description=str(payload.get("description") or ""),
+        labels=split_labels(payload.get("labels")),
+        web_url=str(payload.get("web_url") or ""),
+        author_username=str(author.get("username") or ""),
+        author_url=str(author.get("web_url") or ""),
+        source_branch=str(payload.get("source_branch") or ""),
+        state=str(payload.get("state") or ""),
+    )

glab_release_notes/render.py

@@ -0,0 +1,73 @@
+"""Build the markdown sections of the release notes."""
+
+from glab_release_notes import constants
+from glab_release_notes.config import NotesConfig
+from glab_release_notes.models import MergeRequest, SectionSpec
+
+type Sections = dict[str, str]
+
+
+def format_entry(
+    *,
+    text: str,
+    spec: SectionSpec,
+    mr: MergeRequest,
+    ticket: str | None,
+    jira_base: str | None = None,
+) -> str:
+    """Build a single list item for the release notes."""
+    links = [f"[#{mr.iid}]({mr.web_url})"]
+    if ticket is not None and jira_base is not None:
+        links.append(f"[{ticket}]({jira_base}/{ticket})")
+    emoji = f"{spec.emoji} " if spec.emoji else ""
+    return f"* {emoji}{text} ({', '.join(links)}) by [@{mr.author_username}]({mr.author_url})"
+
+
+def render_unreleased(sections: Sections, cfg: NotesConfig) -> str:
+    """Build the unreleased block.
+
+    The ``always_keep`` sections are always present; other sections only when non-empty.
+    """
+    blocks: list[str] = []
+    for header in cfg.section_order:
+        _append_section_block(blocks, sections, header, cfg=cfg)
+    return constants.double_newline.join(blocks)
+
+
+def _append_section_block(
+    blocks: list[str],
+    sections: Sections,
+    header: str,
+    *,
+    cfg: NotesConfig,
+) -> None:
+    body = sections.get(header, "")
+    keep_empty = header in cfg.always_keep
+    if not body and not keep_empty:
+        return
+    prefix = f"{cfg.section_prefix}{header}"
+    if body:
+        blocks.append(f"{prefix}{constants.double_newline}{body}")
+        return
+    blocks.append(prefix)
+
+
+def assemble(prefix: str, unreleased: str, postfix: str) -> str:
+    """Join the file parts with a single trailing newline."""
+    chunks = [prefix.rstrip(), unreleased.strip()]
+    post_stripped = postfix.strip()
+    if post_stripped:
+        chunks.append(post_stripped)
+    joined = constants.double_newline.join(chunks)
+    return f"{joined}\n"
+
+
+def prepend_entry(sections: Sections, header: str, entry: str) -> Sections:
+    """Add an entry at the top of a section."""
+    current = sections.get(header, "")
+    if not current:
+        sections[header] = entry
+        return sections
+    combined = f"{entry}\n{current}"
+    sections[header] = combined.strip()
+    return sections

glab_release_notes/split.py

@@ -0,0 +1,58 @@
+"""Split the release notes markdown into sections."""
+
+import re
+
+from glab_release_notes import constants
+from glab_release_notes.config import NotesConfig
+from glab_release_notes.models import ReleaseNotesError
+
+
+def _find_unreleased(notes_markdown: str, cfg: NotesConfig) -> re.Match[str]:
+    header = cfg.unreleased_header
+    match = re.search(rf"^{re.escape(header)}\s*$", notes_markdown, re.MULTILINE)
+    if match is None:
+        msg = f"Header {header!r} not found"
+        raise ReleaseNotesError(msg)
+    return match
+
+
+def _cut_after_header(prefix: str, rest: str) -> tuple[str, str, str]:
+    next_version = constants.version_line_re.search(rest)
+    if next_version is None:
+        return prefix, rest, ""
+    start = next_version.start()
+    return prefix, rest[:start], rest[start:]
+
+
+def split_unreleased(notes_markdown: str, cfg: NotesConfig) -> tuple[str, str, str]:
+    """Cut the file into a header, the unreleased block, and the rest."""
+    match = _find_unreleased(notes_markdown, cfg)
+    prefix = notes_markdown[: match.end()]
+    rest = notes_markdown[match.end() :]
+    return _cut_after_header(prefix, rest)
+
+
+def _header_name(raw: str) -> str:
+    return constants.anchor_re.sub("", raw).strip()
+
+
+def _section_end(matches: list[re.Match[str]], index: int, unreleased: str) -> int:
+    if index + 1 < len(matches):
+        return matches[index + 1].start()
+    return len(unreleased)
+
+
+def _fill_sections(matches: list[re.Match[str]], unreleased: str) -> dict[str, str]:
+    sections: dict[str, str] = {}
+    for index, match in enumerate(matches):
+        title = _header_name(match.group(1))
+        end = _section_end(matches, index, unreleased)
+        sections[title] = unreleased[match.end() : end].strip()
+    return sections
+
+
+def parse_sections(unreleased: str, cfg: NotesConfig) -> dict[str, str]:
+    """Parse the section lines of the unreleased block."""
+    section_re = re.compile(rf"^{re.escape(cfg.section_prefix)}(.+)$", re.MULTILINE)
+    matches = list(section_re.finditer(unreleased))
+    return _fill_sections(matches, unreleased)

glab_release_notes-0.1.0.dist-info/METADATA

@@ -0,0 +1,277 @@
+Metadata-Version: 2.4
+Name: glab-release-notes
+Version: 0.1.0
+Summary: GitLab release notes from merged MRs: validate labels and quote, append entries, and promote them under a version in CI.
+Keywords: gitlab,release-notes,changelog,ci,merge-request
+Author: Vladimir Voronov
+Author-email: Vladimir Voronov <vvoronov@mwnts.ru>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Topic :: Utilities
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/redb0/glab-release-notes
+Project-URL: Repository, https://github.com/redb0/glab-release-notes
+Project-URL: Issues, https://github.com/redb0/glab-release-notes/issues
+Project-URL: Changelog, https://github.com/redb0/glab-release-notes/releases
+Description-Content-Type: text/markdown
+
+# Glab Release Notes
+
+Automatically add the changes from each merged merge request to human-readable release notes in a file.
+
+This is a GitLab-oriented take on [latest-changes](https://github.com/tiangolo/latest-changes): a small, dependency-free CLI that runs in your GitLab CI and keeps a `release-notes.md` up to date as merge requests get merged.
+
+Unlike tools that scrape `git log` or conventional-commit messages, it reads the data **from the merge request itself**:
+
+* a **label** decides which section the entry lands in,
+* a **one-line quote** (`> …`) in the MR description is the entry text,
+* a **ticket key** in the source-branch name (e.g. `FMT-1110`) becomes an optional Jira link.
+
+So the person writing the MR writes the one sentence that matters, and CI takes care of the formatting, links, author, and ordering.
+
+## How it works
+
+A release notes file is plain Markdown with an `## Latest Changes` block at the top and versioned blocks below it:
+
+```Markdown
+# Release notes
+
+## Latest Changes
+
+### Features
+
+### Fixes
+
+## 0.8.1
+
+### Fixes {#fix_0.8.1}
+
+* 🐛 Fixed a crash on empty input ([#35](https://gitlab.example/your/project/-/merge_requests/35)) by [@alice](https://gitlab.example/alice)
+```
+
+After a merge request is merged, the `append` command finds the `## Latest Changes` block and adds a new list item to the section chosen by the MR's label:
+
+> ## Latest Changes
+>
+> ### Features
+>
+> * ✨ Add support for detailed gRPC errors ([#123](https://gitlab.example/your/project/-/merge_requests/123), [FMT-1110](https://jira.example/browse/FMT-1110)) by [@bob](https://gitlab.example/bob)
+
+The entry is built from:
+
+* the **label** → section and emoji (see [Using labels](#using-labels)),
+* the **last non-empty `> …` quote** in the MR description → the entry text,
+* the **ticket key** parsed from the source branch name → a Jira link (only when a `--jira-base` is given),
+* the MR **author** and **URL** → trailing `by [@author](…)`.
+
+The entry is prepended to the top of the section so the newest change reads first. Because the notes are just a file in your repo, you can later tweak, reorder, or extend any entry by hand.
+
+## Using labels
+
+A merge request is routed to a section by its labels. The built-in default mapping is:
+
+| Label       | Section         | Emoji |
+| ----------- | --------------- | ----- |
+| `feature`   | `Features`      | ✨    |
+| `bug`       | `Fixes`         | 🐛    |
+| `docs`      | `Documentation` | 📝    |
+| `ci`        | `CI`            | 👷    |
+
+Labels that are never recorded into the notes:
+
+* `release`, `refactor`, `test`, `chore`, `style`
+
+Rules:
+
+* A merge request must carry **either** a section label **or** a skip label.
+* A **skip label wins** if both a section label and a skip label are present.
+* With several section labels, the first one in the configured order wins.
+* A section label **requires** a `> …` quote in the description; a skip label does not.
+
+`Features` and `Fixes` always exist (even when empty). The other sections appear only once they have at least one entry.
+
+## Getting started
+
+1. **Add the notes file** (if you don't have one), e.g. `docs/release-notes.md`:
+
+   ```Markdown
+   # Release notes
+
+   ## Latest Changes
+
+   ### Features
+
+   ### Fixes
+   ```
+
+2. **Add a merge-request template** that asks authors to set a label and write a one-line quote. A minimal `Default.md`:
+
+   ```Markdown
+   /label ~feature
+
+   ## Release notes
+
+   One line in a quote. No emojis and no links — CI adds those after the merge.
+
+   >
+   ```
+
+3. **Add the CI jobs** (see [CI wiring](#ci-wiring)).
+
+That's enough for `validate` and `append` to work. `promote` is what your release job calls.
+
+## Commands
+
+```
+glab-release-notes [--config PATH] [--file PATH] <command>
+```
+
+* `validate` — a gate for the MR pipeline. Fails the pipeline when the MR has neither a section label nor a skip label, or has a section label but no `> …` quote.
+* `append` — after a merge, appends the entry to the `## Latest Changes` block and pushes a `chore(notes): add entry for MR !<iid>` commit. It retries on a push race and is idempotent: an already-recorded MR is skipped.
+* `promote` — moves the non-empty sections of `## Latest Changes` under a new `## <version>` heading with anchors, then empties the block back to the always-kept sections. `--version` is required; `--no-push` rewrites the file only so your release process can own the commit.
+
+## CI wiring
+
+The tool talks to the GitLab API using CI variables, so it is bound to whichever project's pipeline runs it:
+
+* `CI_API_V4_URL`, `CI_PROJECT_ID`, `GITLAB_API_TOKEN` — API endpoint and auth;
+* `CI_MERGE_REQUEST_IID` — used by `validate`;
+* `CI_COMMIT_SHA` — used by `append` to find the MR of the current commit.
+
+A typical `.gitlab-ci.yml`:
+
+```yaml
+validate-release-notes:
+  stage: linter
+  script:
+    - uv run glab-release-notes validate
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+
+append-release-notes:
+  stage: linter
+  variables:
+    GIT_DEPTH: 0
+  before_script:
+    - !reference [.base_git_pre_settings, script]   # git credentials for the push
+  script:
+    - uv run glab-release-notes append --jira-base https://jira.example/browse
+  rules:
+    - if: $CI_COMMIT_TAG || $CI_PIPELINE_SOURCE == "merge_request_event"
+      when: never
+    - if: '$CI_COMMIT_MESSAGE =~ /^chore\(notes\)/'
+      when: never
+    - if: $CI_COMMIT_BRANCH == "main" && $CI_PIPELINE_SOURCE == "push"
+```
+
+The `chore(notes)` rule prevents the job from re-running on its own commits, and `GIT_DEPTH: 0` gives `append` a full history. The `before_script` must configure git with credentials able to push to the target branch (see [Pushing to a protected branch](#pushing-to-a-protected-branch)).
+
+### Promoting on release
+
+Call `promote` in your release job, right before (and, with `--no-push`, folded into) the release commit:
+
+```yaml
+    - uv run glab-release-notes promote --version "${version}" --no-push
+```
+
+## Existing MRs — running manually
+
+`append` resolves the MR from `CI_COMMIT_SHA` by default. To record a specific merge request by hand — for example one that was merged before you added this — run `append` on the target branch with the `MR_IID` variable set:
+
+```
+MR_IID=123 uv run glab-release-notes append --jira-base https://jira.example/browse
+```
+
+This is also the escape hatch for any MR the automatic run skipped.
+
+## Configuration
+
+The wording of the release notes — the file, the `Latest Changes` header, the sections, the labels, and the skip labels — is configurable, in the same spirit as [latest-changes](https://github.com/tiangolo/latest-changes). Put a `release-notes.toml` in the repo root and it is picked up automatically; pass `--config PATH` to point at a different file. Without a config file, the built-in defaults from [Using labels](#using-labels) apply.
+
+Precedence: CLI flags (`--file`) > config file > built-in defaults.
+
+```toml
+# release-notes.toml
+file = "docs/release-notes.md"        # the notes file (CLI --file wins)
+unreleased_header = "## Latest Changes"
+section_prefix = "### "
+skip_labels = ["release", "refactor", "test", "chore", "style"]
+always_keep = ["Features", "Fixes"]
+
+[[section]]
+label = "feature"
+header = "Features"
+emoji = "✨"
+anchor_prefix = "feat"
+
+[[section]]
+label = "bug"
+header = "Fixes"
+emoji = "🐛"
+anchor_prefix = "fix"
+
+[[section]]
+label = "docs"
+header = "Documentation"
+emoji = "📝"
+anchor_prefix = "docs"
+
+[[section]]
+label = "ci"
+header = "CI"
+emoji = "👷"
+anchor_prefix = "ci"
+```
+
+Keys:
+
+* `file` — the notes file to update. Defaults to `docs/release-notes.md`.
+* `unreleased_header` — the header of the accumulating block. Defaults to `## Latest Changes`.
+* `section_prefix` — the prefix of the section headers inside the block. Defaults to `### `.
+* `skip_labels` — labels that are never recorded. A skip label also wins over a section label.
+* `always_keep` — section headers that are always rendered, even when empty. Defaults to `["Features", "Fixes"]`; use `[]` to render a section only once it has an entry (the latest-changes behavior).
+* `[[section]]` — one table per section:
+    * `label` (required) — the GitLab label that routes an MR to this section.
+    * `header` (required) — the section header text.
+    * `emoji` (optional) — the emoji prefixed to entries in this section. Omit it for a plain entry.
+    * `anchor_prefix` (optional) — the anchor prefix used when promoting, e.g. `{#feat_1.0.0}`. Defaults to the label.
+
+The order of `[[section]]` tables matters in both directions: it is the display order of the sections, and the first matching label wins when an MR carries several section labels.
+
+The entry line format itself is fixed: `* <emoji> <text> (links) by <author>`. It is not a template.
+
+## Pushing to a protected branch
+
+`append` and `promote` (without `--no-push`) `git commit` and `git push` the updated notes. If your target branch is protected against direct pushes, the CI job must be running with credentials that can push to it.
+
+In GitLab that usually means one of:
+
+* the job runs as a user/role allowed to push to the branch, or
+* you pass a token to the git setup (the `!reference [.base_git_pre_settings, script]` pattern above) that can push.
+
+The commits are attributed to the CI identity, not to any individual author.
+
+## Development
+
+```
+uv sync
+uv run ruff check .
+uv run ruff format --check .
+uv run mypy glab_release_notes tests
+uv run pytest
+```
+
+Releases are managed with [commitizen](https://github.com/commitizen/commitizen): `uv run cz bump` updates the version and `CHANGELOG.md` and tags the commit. A GitHub Release on that tag publishes the package to PyPI via trusted publishing (`.github/workflows/publish.yaml`).
+
+## License
+
+This project is licensed under the terms of the MIT license.

glab_release_notes-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+glab_release_notes/__init__.py,sha256=sDDTvPs01f4frME4JCUf0dXNyqneG_Bcagyp1ZMu7ZQ,894
+glab_release_notes/__main__.py,sha256=nxz-bFr3jXCYad399e1xnwgjVPSA6RjJ9JhcNt6gZ58,133
+glab_release_notes/api.py,sha256=vNQXuNDc7mJJ0q6p_Az3AOEfYIaC_1xatuiHs5XprfM,1337
+glab_release_notes/append_cmd.py,sha256=VSHHSogGZEGxwpFsRdUlag_fcdPOj97c9f2_3_fKETA,2838
+glab_release_notes/cli.py,sha256=xjNpje_gDD93dmgGZ81E0ndx0g7ONuXpe2dnOCQdKvc,3908
+glab_release_notes/config.py,sha256=vB7LJkq11qQnWGSqcEWYkkoiZZCVBPi6gSF1C65fFlg,6442
+glab_release_notes/constants.py,sha256=ZaM1ru__ncVrciWfA90eCTHJP89bQDm4_4P5nxJGrHM,430
+glab_release_notes/edit.py,sha256=jjTh1FNSKQxCSIg2GsZ6kKwUzlP5vraK2MhQH6CtLIM,3374
+glab_release_notes/gitops.py,sha256=08o9oK10PsMDuiIKA0qyzzEcvJmgRVe8_ALetxJuqvc,1926
+glab_release_notes/http.py,sha256=TUZ2IAQZcrGOgxKaq069gpCjX3eesFhZTs2-JZan8fM,1311
+glab_release_notes/load.py,sha256=7T3IbKh90c1xfL8Mcy8EthZdPQr_iyDK0gnWBgSzszw,877
+glab_release_notes/models.py,sha256=3b0nkIjJcTIsZowNlr7vc6o0SSisnEejsjpwkDWQ-dE,1007
+glab_release_notes/parse.py,sha256=-3b84m6yeVkVGhZoCN0q6on-nFsr-dyPqvnrSWez89A,2182
+glab_release_notes/payload.py,sha256=kv0yVNcfI3PjtN1W4RhFEzdQbymwnNt7d9TyP1Cr7zc,1682
+glab_release_notes/render.py,sha256=mYnxbgJwjlx0xzSHEB8FvCMxlSdwApQSYVKxEVnDanA,2257
+glab_release_notes/split.py,sha256=-Vk_jw92jGD0dpGeSBUEqx0pBQcHm2ZTUjX3AKWyQV8,2084
+glab_release_notes-0.1.0.dist-info/licenses/LICENSE,sha256=2ONWB-4UEk0c1mnrV_w-wAKgqs66p70nrQCXksEnx04,1073
+glab_release_notes-0.1.0.dist-info/WHEEL,sha256=si2p8vW03RnhyBnhWl4tj-ObJa78SpE-c9HsEtblGR0,80
+glab_release_notes-0.1.0.dist-info/entry_points.txt,sha256=9c4ahZ3Z3LXEnU_YUSHWdI3oCTdE3KUgOaLqB7_Ph34,68
+glab_release_notes-0.1.0.dist-info/METADATA,sha256=TGlRRfqwzRxGDdqdeOJB5vfnPrCPB1ntGkDGwDYsKAA,11035
+glab_release_notes-0.1.0.dist-info/RECORD,,

glab_release_notes-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.5
+Root-Is-Purelib: true
+Tag: py3-none-any

glab_release_notes-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+glab-release-notes = glab_release_notes.cli:main
+

glab_release_notes-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vladimir Voronov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.