semvertag 0.1.0__py3-none-any.whl

semvertag/__main__.py

@@ -0,0 +1,178 @@
+import errno
+import importlib.metadata
+import typing
+
+import modern_di_typer
+import pydantic
+import typer
+
+from semvertag import ioc
+from semvertag._errors import ConfigError, SemvertagError
+from semvertag._output import Output, build_json_output, build_rich_output
+from semvertag._settings import Settings, apply_cli_overlay
+from semvertag._use_case import SemvertagUseCase
+
+
+_PACKAGE_NAME: typing.Final = "semvertag"
+
+
+MAIN_APP: typing.Final = typer.Typer(
+    name="semvertag",
+    help=("Auto-tag GitLab repos with semantic version tags — one tool, two strategies."),
+    no_args_is_help=True,
+    add_completion=True,
+)
+
+modern_di_typer.setup_di(MAIN_APP, ioc.container)
+
+
+def _version_callback(value: bool) -> None:
+    if not value:
+        return
+    try:
+        version = importlib.metadata.version(_PACKAGE_NAME)
+    except importlib.metadata.PackageNotFoundError:
+        version = "0"
+    typer.echo(version)
+    raise typer.Exit
+
+
+def _collect_overrides(  # noqa: PLR0913
+    *,
+    project_id: int | None,
+    strategy: str | None,
+    token: str | None,
+    default_branch: str | None,
+    gitlab_endpoint: str | None,
+    request_timeout: float | None,
+) -> dict[str, typing.Any]:
+    overrides: dict[str, typing.Any] = {}
+    if project_id is not None:
+        overrides["project_id"] = project_id
+    if strategy is not None:
+        overrides["strategy"] = strategy
+    if token is not None:
+        overrides["gitlab.token"] = pydantic.SecretStr(token)
+    if default_branch is not None:
+        overrides["default_branch"] = default_branch
+    if gitlab_endpoint is not None:
+        overrides["gitlab.endpoint"] = gitlab_endpoint
+    if request_timeout is not None:
+        overrides["request_timeout"] = request_timeout
+    return overrides
+
+
+def _config_error_from_validation(exc: pydantic.ValidationError) -> ConfigError:
+    first: typing.Final = exc.errors()[0]
+    loc: typing.Final = ".".join(str(part) for part in first.get("loc", ()))
+    detail: typing.Final = first.get("msg", "invalid value")
+    msg: typing.Final = f"Configuration error at '{loc}': {detail}. Check environment variables and command-line flags."
+    return ConfigError(msg)
+
+
+@MAIN_APP.callback()
+def _main_callback(  # noqa: PLR0913
+    ctx: typer.Context,
+    project_id: typing.Annotated[
+        int | None,
+        typer.Option("--project-id", help="GitLab project id (or set CI_PROJECT_ID)."),
+    ] = None,
+    strategy: typing.Annotated[
+        str | None,
+        typer.Option("--strategy", help="Bump strategy: branch-prefix | conventional-commits."),
+    ] = None,
+    token: typing.Annotated[
+        str | None,
+        typer.Option("--token", help="API token (overrides SEMVERTAG_TOKEN)."),
+    ] = None,
+    default_branch: typing.Annotated[
+        str | None,
+        typer.Option("--default-branch", help="Default branch name override."),
+    ] = None,
+    gitlab_endpoint: typing.Annotated[
+        str | None,
+        typer.Option("--gitlab-endpoint", help="GitLab API endpoint URL."),
+    ] = None,
+    request_timeout: typing.Annotated[
+        float | None,
+        typer.Option("--request-timeout", help="Per-request timeout in seconds (clamped to 10)."),
+    ] = None,
+    _version: typing.Annotated[
+        bool | None,
+        typer.Option("--version", callback=_version_callback, is_eager=True, help="Show version and exit."),
+    ] = None,
+) -> None:
+    if ctx.resilient_parsing:
+        return
+
+    try:
+        settings = Settings()
+        try:
+            overrides = _collect_overrides(
+                project_id=project_id,
+                strategy=strategy,
+                token=token,
+                default_branch=default_branch,
+                gitlab_endpoint=gitlab_endpoint,
+                request_timeout=request_timeout,
+            )
+            settings = apply_cli_overlay(settings, overrides)
+        except ValueError as exc:
+            raise ConfigError(str(exc)) from exc
+    except pydantic.ValidationError as exc:
+        err = _config_error_from_validation(exc)
+        typer.echo(f"Error: {err}", err=True)
+        raise typer.Exit(code=err.exit_code) from err
+    except ConfigError as err:
+        typer.echo(f"Error: {err}", err=True)
+        raise typer.Exit(code=err.exit_code) from err
+
+    app_container = modern_di_typer.fetch_di_container(ctx)
+    app_container.set_context(Settings, settings)
+
+
+@modern_di_typer.inject
+def _resolve_use_case(
+    use_case: typing.Annotated[SemvertagUseCase, modern_di_typer.FromDI(SemvertagUseCase)],
+) -> SemvertagUseCase:
+    return use_case
+
+
+@MAIN_APP.command("tag")
+def _tag_command(
+    ctx: typer.Context,
+    quiet: typing.Annotated[
+        bool,
+        typer.Option("--quiet", help="Suppress progress narrative; final result still emits."),
+    ] = False,
+    json_flag: typing.Annotated[
+        bool,
+        typer.Option("--json", help="Emit a JSON envelope on stdout instead of human-readable output."),
+    ] = False,
+) -> None:
+    output: Output = build_json_output(quiet=quiet) if json_flag else build_rich_output(quiet=quiet)
+    try:
+        use_case = _resolve_use_case(ctx=ctx)
+        use_case(output=output)
+    except ImportError as exc:
+        err = ConfigError(f"Required module unavailable: {exc}.")
+        output.error(str(err))
+        raise typer.Exit(code=err.exit_code) from exc
+    except SemvertagError as err:
+        output.error(str(err))
+        raise typer.Exit(code=err.exit_code) from err
+    except BrokenPipeError as exc:
+        raise typer.Exit(code=0) from exc
+    except OSError as exc:
+        if exc.errno == errno.EPIPE:
+            raise typer.Exit(code=0) from exc
+        raise
+
+
+def main() -> None:
+    with ioc.container:
+        MAIN_APP()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

semvertag/_commit_parse.py

@@ -0,0 +1,29 @@
+import typing
+
+
+def subject_line(message: str) -> str:
+    for line in message.splitlines():
+        if line.strip():
+            return line.rstrip()
+    return ""
+
+
+def body_lines(message: str) -> list[str]:
+    lines: typing.Final = message.splitlines()
+    subject_seen = False
+    separator_seen = False
+    collected: list[str] = []
+    for line in lines:
+        if not subject_seen:
+            if line.strip():
+                subject_seen = True
+            continue
+        if not separator_seen:
+            if not line.strip():
+                separator_seen = True
+                continue
+            collected.append(line.rstrip())
+            continue
+        if line.strip():
+            collected.append(line.rstrip())
+    return collected

semvertag/_errors.py

@@ -0,0 +1,17 @@
+import typing
+
+
+class SemvertagError(Exception):
+    exit_code: typing.ClassVar[int] = 1
+
+
+class ConfigError(SemvertagError):
+    exit_code: typing.ClassVar[int] = 2
+
+
+class AuthError(SemvertagError):
+    exit_code: typing.ClassVar[int] = 3
+
+
+class ProviderAPIError(SemvertagError):
+    exit_code: typing.ClassVar[int] = 4

semvertag/_output.py

@@ -0,0 +1,78 @@
+import dataclasses
+import json
+import sys
+import typing
+
+import rich.console
+
+from semvertag._redact import redact
+from semvertag._types import RunResult
+
+
+_COMMIT_SHORT_LEN: typing.Final = 7
+
+
+class Output(typing.Protocol):
+    def progress(self, message: str) -> None: ...
+    def emit(self, result: RunResult) -> None: ...
+    def error(self, message: str) -> None: ...
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class RichOutput:
+    info_console: rich.console.Console
+    error_console: rich.console.Console
+    quiet: bool = False
+
+    def progress(self, message: str) -> None:
+        if self.quiet:
+            return
+        self.info_console.print(redact(message), markup=False, highlight=False)
+
+    def emit(self, result: RunResult) -> None:
+        self.info_console.print(redact(_format_result(result)), markup=False, highlight=False)
+
+    def error(self, message: str) -> None:
+        self.error_console.print(redact(message), markup=False, highlight=False)
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class JsonOutput:
+    error_console: rich.console.Console
+    quiet: bool = False
+
+    def progress(self, message: str) -> None:
+        _ = message
+
+    def emit(self, result: RunResult) -> None:
+        payload: typing.Final = json.dumps(dataclasses.asdict(result), separators=(",", ":"))
+        sys.stdout.write(payload + "\n")
+        sys.stdout.flush()
+
+    def error(self, message: str) -> None:
+        self.error_console.print(redact(message), markup=False, highlight=False)
+
+
+def _format_result(result: RunResult) -> str:
+    if result.status == "created":
+        short: typing.Final = (result.commit or "")[:_COMMIT_SHORT_LEN]
+        return f"Created tag {result.tag} on commit {short} (strategy: {result.strategy}, bump: {result.bump})"
+    return (
+        f"No tag created (status: {result.status}, strategy: {result.strategy}, "
+        f"bump: {result.bump}, reason: {result.reason})"
+    )
+
+
+def build_rich_output(*, quiet: bool = False) -> RichOutput:
+    return RichOutput(
+        info_console=rich.console.Console(),
+        error_console=rich.console.Console(stderr=True),
+        quiet=quiet,
+    )
+
+
+def build_json_output(*, quiet: bool = False) -> JsonOutput:
+    return JsonOutput(
+        error_console=rich.console.Console(stderr=True),
+        quiet=quiet,
+    )

semvertag/_redact.py

@@ -0,0 +1,20 @@
+import re
+import typing
+
+
+_REDACTION: typing.Final = "***"
+_TOKEN_PATTERN: typing.Final = re.compile(
+    r"glpat-[A-Za-z0-9_\-]{20,}"
+    r"|github_pat_[A-Za-z0-9_]{20,}"
+    r"|ghp_[A-Za-z0-9]{20,}"
+    r"|gho_[A-Za-z0-9]{20,}"
+    r"|ghu_[A-Za-z0-9]{20,}"
+    r"|ghs_[A-Za-z0-9]{20,}"
+    r"|ghr_[A-Za-z0-9]{20,}"
+    r"|ATBB[A-Za-z0-9]{20,}"
+    r"|\b[0-9a-fA-F]{32,}\b",
+)
+
+
+def redact(text: str) -> str:
+    return _TOKEN_PATTERN.sub(_REDACTION, text)

semvertag/_settings.py

@@ -0,0 +1,107 @@
+import logging
+import typing
+
+import pydantic
+import pydantic_settings
+
+from semvertag.strategies.branch_prefix import BranchPrefixConfig
+from semvertag.strategies.conventional_commits import ConventionalCommitsConfig
+
+
+_logger: typing.Final = logging.getLogger(__name__)
+
+_REQUEST_TIMEOUT_CEILING: typing.Final = 10.0
+_ENV_PREFIX: typing.Final = "SEMVERTAG_"
+_ENV_NESTED_DELIMITER: typing.Final = "__"
+
+
+class GitLabConfig(pydantic_settings.BaseSettings):
+    model_config = pydantic_settings.SettingsConfigDict(
+        env_prefix="SEMVERTAG_GITLAB__",
+        case_sensitive=False,
+        extra="ignore",
+        populate_by_name=True,
+    )
+
+    endpoint: str = "https://gitlab.com"
+    token: pydantic.SecretStr = pydantic.Field(
+        default=pydantic.SecretStr(""),
+        validation_alias=pydantic.AliasChoices(
+            "SEMVERTAG_GITLAB__TOKEN",
+            "SEMVERTAG_TOKEN",
+            "CI_JOB_TOKEN",
+            "GITLAB_TOKEN",
+        ),
+    )
+
+
+class GitHubConfig(pydantic_settings.BaseSettings):
+    model_config = pydantic_settings.SettingsConfigDict(
+        env_prefix="SEMVERTAG_GITHUB__",
+        case_sensitive=False,
+        extra="ignore",
+        populate_by_name=True,
+    )
+
+    token: pydantic.SecretStr = pydantic.Field(
+        default=pydantic.SecretStr(""),
+        validation_alias=pydantic.AliasChoices(
+            "SEMVERTAG_GITHUB__TOKEN",
+            "SEMVERTAG_TOKEN",
+            "GITHUB_TOKEN",
+        ),
+    )
+
+
+class Settings(pydantic_settings.BaseSettings):
+    model_config = pydantic_settings.SettingsConfigDict(
+        env_prefix=_ENV_PREFIX,
+        env_nested_delimiter=_ENV_NESTED_DELIMITER,
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    strategy: typing.Literal["branch-prefix", "conventional-commits"] = "branch-prefix"
+    default_branch: str | None = None
+    request_timeout: float = pydantic.Field(default=8.0, gt=0)
+    project_id: int | None = pydantic.Field(
+        default=None,
+        validation_alias=pydantic.AliasChoices("SEMVERTAG_PROJECT_ID", "CI_PROJECT_ID"),
+    )
+    gitlab: GitLabConfig = pydantic.Field(default_factory=GitLabConfig)
+    github: GitHubConfig = pydantic.Field(default_factory=GitHubConfig)
+    branch_prefix: BranchPrefixConfig = pydantic.Field(default_factory=BranchPrefixConfig)
+    conventional_commits: ConventionalCommitsConfig = pydantic.Field(default_factory=ConventionalCommitsConfig)
+
+    @pydantic.field_validator("request_timeout")
+    @classmethod
+    def _clamp_request_timeout(cls, value: float) -> float:
+        if value > _REQUEST_TIMEOUT_CEILING:
+            _logger.warning(
+                "request_timeout=%.3f exceeds ceiling %.1f; clamping to %.1f",
+                value,
+                _REQUEST_TIMEOUT_CEILING,
+                _REQUEST_TIMEOUT_CEILING,
+            )
+            return _REQUEST_TIMEOUT_CEILING
+        return value
+
+
+def apply_cli_overlay(settings: Settings, overrides: dict[str, typing.Any]) -> Settings:
+    top_updates: dict[str, typing.Any] = {}
+    nested_updates: dict[str, dict[str, typing.Any]] = {}
+    for dotted_key, value in overrides.items():
+        head, _, leaf = dotted_key.partition(".")
+        if "." in leaf:
+            msg = f"CLI overlay key '{dotted_key}' exceeds nesting depth 2."
+            raise ValueError(msg)
+        if leaf:
+            nested_updates.setdefault(head, {})[leaf] = value
+        else:
+            top_updates[head] = value
+    for head, leaves in nested_updates.items():
+        top_updates[head] = getattr(settings, head).model_copy(update=leaves)
+    copied = settings.model_copy(update=top_updates)
+    # Re-validate to trigger field validators (e.g. _clamp_request_timeout).
+    # getattr (not model_dump) preserves live SecretStr values.
+    return type(settings).model_validate({name: getattr(copied, name) for name in type(copied).model_fields})

semvertag/_transport.py

@@ -0,0 +1,84 @@
+import datetime
+import email.utils
+import random
+import time
+import typing
+
+import httpx2
+
+
+RETRYABLE_STATUSES: typing.Final[frozenset[int]] = frozenset({408, 429, 500, 502, 503, 504})
+RETRYABLE_EXCEPTIONS: typing.Final[tuple[type[BaseException], ...]] = (
+    httpx2.ConnectError,
+    httpx2.ReadTimeout,
+    httpx2.WriteTimeout,
+    httpx2.RemoteProtocolError,
+)
+MAX_ATTEMPTS: typing.Final = 3
+MAX_WALL_SECONDS: typing.Final = 30.0
+BACKOFF_BASE_SECONDS: typing.Final = 1.0
+
+
+class RetryingTransport(httpx2.BaseTransport):
+    def __init__(self, inner: httpx2.BaseTransport | None = None) -> None:
+        self._inner: httpx2.BaseTransport = inner or httpx2.HTTPTransport()
+
+    def handle_request(self, request: httpx2.Request) -> httpx2.Response:
+        start: typing.Final = time.monotonic()
+        last_response: httpx2.Response | None = None
+        last_exc: BaseException | None = None
+        for attempt in range(MAX_ATTEMPTS):
+            try:
+                response = self._inner.handle_request(request)
+            except RETRYABLE_EXCEPTIONS as exc:
+                last_exc, last_response = exc, None
+            else:
+                if response.status_code not in RETRYABLE_STATUSES:
+                    return response
+                last_response, last_exc = response, None
+            if attempt == MAX_ATTEMPTS - 1:
+                break
+            sleep_seconds = _compute_sleep(attempt, last_response)
+            if time.monotonic() - start + sleep_seconds > MAX_WALL_SECONDS:
+                break
+            time.sleep(sleep_seconds)
+        if last_response is not None:
+            return last_response
+        if last_exc is not None:
+            raise last_exc
+        msg = "RetryingTransport loop invariant violated"  # pragma: no cover
+        raise RuntimeError(msg)  # pragma: no cover
+
+    def close(self) -> None:
+        self._inner.close()
+
+
+def _compute_sleep(attempt: int, last_response: httpx2.Response | None) -> float:
+    backoff: typing.Final = random.uniform(0.0, BACKOFF_BASE_SECONDS * (2**attempt))  # noqa: S311
+    if last_response is not None and last_response.status_code in RETRYABLE_STATUSES:
+        parsed: typing.Final = _parse_retry_after(last_response.headers.get("retry-after"), time.time())
+        if parsed is not None:
+            return max(parsed, backoff)
+    return backoff
+
+
+def _parse_retry_after(value: str | None, now_epoch: float) -> float | None:
+    if value is None:
+        return None
+    stripped: typing.Final = value.strip()
+    if not stripped:
+        return None
+    try:
+        seconds = float(stripped)
+    except (TypeError, ValueError):
+        pass
+    else:
+        return seconds if seconds >= 0.0 else None
+    try:
+        parsed_dt = email.utils.parsedate_to_datetime(stripped)
+        if parsed_dt.tzinfo is None:
+            parsed_dt = parsed_dt.replace(tzinfo=datetime.timezone.utc)
+        delta: typing.Final = parsed_dt.timestamp() - now_epoch
+    except (TypeError, ValueError, OverflowError):
+        return None
+    return max(0.0, delta)

semvertag/_types.py

@@ -0,0 +1,46 @@
+import dataclasses
+import enum
+import typing
+
+
+class Bump(enum.Enum):
+    NONE = "none"
+    PATCH = "patch"
+    MINOR = "minor"
+    MAJOR = "major"
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class ConfigSource:
+    layer: typing.Literal["cli", "env", "default"]
+    detail: str
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class RunResult:
+    schema_version: str = "1.0"
+    strategy: str
+    bump: str
+    status: str
+    tag: str | None
+    commit: str | None
+    reason: str | None
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class Commit:
+    sha: str
+    message: str
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class Tag:
+    name: str
+    commit_sha: str
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class CheckResult:
+    name: str
+    status: typing.Literal["passed", "failed", "skipped"]
+    cause: str

semvertag/_use_case.py

@@ -0,0 +1,127 @@
+import dataclasses
+import typing
+
+import semver
+
+from semvertag._output import Output
+from semvertag._types import Bump, RunResult, Tag
+from semvertag.providers._base import Provider
+from semvertag.strategies._base import BumpStrategy
+
+
+_NO_TAGS_REASON: typing.Final = "No prior semver-conforming tags found; not seeding an initial tag in v1.0."
+_ALREADY_TAGGED_REASON: typing.Final = "Latest commit already tagged."
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class SemvertagUseCase:
+    provider: Provider
+    strategy: BumpStrategy
+
+    def __call__(self, *, output: Output) -> RunResult:
+        output.progress(f"Detected strategy: {self.strategy.name}")
+        output.progress("Fetching latest commit on default branch...")
+        commit: typing.Final = self.provider.get_latest_commit_on_default_branch()
+
+        output.progress("Fetching tag history...")
+        tags: typing.Final = self.provider.list_tags()
+        latest_semver_tag: typing.Final = _pick_latest_semver_tag(tags)
+
+        if latest_semver_tag is None:
+            return self._emit(
+                output=output,
+                bump=Bump.NONE,
+                status="no_tags",
+                tag=None,
+                commit=commit.sha,
+                reason=_NO_TAGS_REASON,
+            )
+
+        if latest_semver_tag.commit_sha == commit.sha:
+            return self._emit(
+                output=output,
+                bump=Bump.NONE,
+                status="already_tagged",
+                tag=latest_semver_tag.name,
+                commit=commit.sha,
+                reason=_ALREADY_TAGGED_REASON,
+            )
+
+        output.progress("Computing bump...")
+        bump: typing.Final = self.strategy.decide(commit)
+        if bump is Bump.NONE:
+            return self._emit(
+                output=output,
+                bump=Bump.NONE,
+                status=self.strategy.no_bump_status,
+                tag=None,
+                commit=commit.sha,
+                reason=self.strategy.no_bump_reason,
+            )
+
+        new_version: typing.Final = _compute_new_version(latest_semver_tag, bump)
+        output.progress(f"Creating tag {new_version}...")
+        self.provider.create_tag(name=new_version, commit_sha=commit.sha)
+        return self._emit(
+            output=output,
+            bump=bump,
+            status="created",
+            tag=new_version,
+            commit=commit.sha,
+            reason=None,
+        )
+
+    def _emit(  # noqa: PLR0913
+        self,
+        *,
+        output: Output,
+        bump: Bump,
+        status: str,
+        tag: str | None,
+        commit: str | None,
+        reason: str | None,
+    ) -> RunResult:
+        result: typing.Final = RunResult(
+            strategy=self.strategy.name,
+            bump=bump.value,
+            status=status,
+            tag=tag,
+            commit=commit,
+            reason=reason,
+        )
+        output.emit(result)
+        return result
+
+
+def _pick_latest_semver_tag(tags: list[Tag]) -> Tag | None:
+    parsed: typing.Final = [(version, tag) for tag, version in _parse_semver_tags(tags)]
+    if not parsed:
+        return None
+    parsed.sort(key=lambda item: item[0])
+    return parsed[-1][1]
+
+
+def _parse_semver_tags(tags: list[Tag]) -> typing.Iterator[tuple[Tag, semver.Version]]:
+    for tag in tags:
+        version = _try_parse_semver(tag.name)
+        if version is not None:
+            yield tag, version
+
+
+def _try_parse_semver(name: str) -> semver.Version | None:
+    try:
+        return semver.Version.parse(name)
+    except ValueError:
+        return None
+
+
+def _compute_new_version(last_tag: Tag, bump: Bump) -> str:
+    version: typing.Final = semver.Version.parse(last_tag.name)
+    if bump is Bump.MAJOR:
+        return str(version.bump_major())
+    if bump is Bump.MINOR:
+        return str(version.bump_minor())
+    if bump is Bump.PATCH:
+        return str(version.bump_patch())
+    msg = f"Cannot compute new version for bump={bump!r}."
+    raise ValueError(msg)

semvertag/ioc.py

@@ -0,0 +1,101 @@
+import typing
+
+import httpx2
+import modern_di
+from modern_di import Scope, providers
+
+from semvertag._errors import ConfigError
+from semvertag._settings import Settings
+from semvertag._transport import RetryingTransport
+from semvertag._use_case import SemvertagUseCase
+from semvertag.providers._http import HttpClient
+from semvertag.providers.gitlab import GitLabProvider, _translate_status, gitlab_auth_headers
+from semvertag.strategies._base import BumpStrategy
+from semvertag.strategies.branch_prefix import BranchPrefixStrategy
+from semvertag.strategies.conventional_commits import ConventionalCommitsStrategy
+
+
+def _build_gitlab_provider(settings: Settings, transport: httpx2.BaseTransport) -> GitLabProvider:
+    if settings.project_id is None:
+        msg = "Project id missing. Set CI_PROJECT_ID or pass --project-id."
+        raise ConfigError(msg)
+    project_id: typing.Final = settings.project_id
+    client: typing.Final = httpx2.Client(
+        transport=transport,
+        base_url=settings.gitlab.endpoint,
+        timeout=settings.request_timeout,
+    )
+    http: typing.Final = HttpClient(
+        client=client,
+        auth_headers=lambda: gitlab_auth_headers(settings.gitlab.token),
+        status_translator=lambda status: _translate_status(status, project_id),
+    )
+    return GitLabProvider(
+        config=settings.gitlab,
+        project_id=project_id,
+        http=http,
+    )
+
+
+def _build_branch_prefix_strategy(settings: Settings) -> BranchPrefixStrategy:
+    return BranchPrefixStrategy(config=settings.branch_prefix)
+
+
+def _build_conventional_commits_strategy(settings: Settings) -> ConventionalCommitsStrategy:
+    return ConventionalCommitsStrategy(config=settings.conventional_commits)
+
+
+def _build_current_strategy(settings: Settings) -> BumpStrategy:
+    if settings.strategy == "conventional-commits":
+        return _build_conventional_commits_strategy(settings)
+    return _build_branch_prefix_strategy(settings)
+
+
+def _close_provider_client(provider: GitLabProvider) -> None:
+    provider.http.client.close()
+
+
+class SettingsGroup(modern_di.Group):
+    settings = providers.ContextProvider(scope=Scope.APP, context_type=Settings)
+
+
+class TransportsGroup(modern_di.Group):
+    transport = providers.Factory(scope=Scope.APP, creator=RetryingTransport)
+
+
+class ProvidersGroup(modern_di.Group):
+    gitlab_provider = providers.Factory(
+        scope=Scope.APP,
+        creator=_build_gitlab_provider,
+        kwargs={"transport": TransportsGroup.transport},
+        cache_settings=providers.CacheSettings(finalizer=_close_provider_client),
+    )
+
+
+class StrategiesGroup(modern_di.Group):
+    branch_prefix_strategy = providers.Factory(scope=Scope.APP, creator=_build_branch_prefix_strategy)
+    conventional_commits_strategy = providers.Factory(scope=Scope.APP, creator=_build_conventional_commits_strategy)
+    current_strategy = providers.Factory(scope=Scope.APP, creator=_build_current_strategy)
+
+
+class UseCasesGroup(modern_di.Group):
+    semvertag_use_case = providers.Factory(
+        scope=Scope.APP,
+        creator=SemvertagUseCase,
+        kwargs={
+            "provider": ProvidersGroup.gitlab_provider,
+            "strategy": StrategiesGroup.current_strategy,
+        },
+    )
+
+
+ALL_GROUPS: typing.Final[list[type[modern_di.Group]]] = [
+    SettingsGroup,
+    TransportsGroup,
+    ProvidersGroup,
+    StrategiesGroup,
+    UseCasesGroup,
+]
+
+
+container: typing.Final = modern_di.Container(groups=ALL_GROUPS)

semvertag/providers/_base.py

@@ -0,0 +1,12 @@
+import typing
+
+from semvertag._types import Commit, Tag
+
+
+class Provider(typing.Protocol):
+    name: str
+
+    def get_default_branch(self) -> str: ...
+    def get_latest_commit_on_default_branch(self) -> Commit: ...
+    def list_tags(self) -> list[Tag]: ...
+    def create_tag(self, name: str, commit_sha: str) -> None: ...

semvertag/providers/_http.py

@@ -0,0 +1,62 @@
+import collections.abc
+import dataclasses
+import typing
+
+import httpx2
+import pydantic
+
+from semvertag._errors import ProviderAPIError
+
+
+T = typing.TypeVar("T", bound=pydantic.BaseModel)
+
+AuthHeaders: typing.TypeAlias = collections.abc.Callable[[], dict[str, str]]
+StatusTranslator: typing.TypeAlias = collections.abc.Callable[[int], None]
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class HttpClient:
+    client: httpx2.Client
+    auth_headers: AuthHeaders
+    status_translator: StatusTranslator
+
+    def request(self, method: str, url: str, *, schema: type[T], **kwargs: typing.Any) -> T:  # noqa: ANN401
+        response = self._request_translated(method, url, **kwargs)
+        payload = self._decode_json(response)
+        try:
+            return schema.model_validate(payload)
+        except pydantic.ValidationError as exc:
+            msg = f"response shape invalid: {exc}"
+            raise ProviderAPIError(msg) from exc
+
+    def request_many(self, method: str, url: str, *, schema: type[T], **kwargs: typing.Any) -> list[T]:  # noqa: ANN401
+        response = self._request_translated(method, url, **kwargs)
+        payload = self._decode_json(response)
+        if not isinstance(payload, list):
+            msg = f"response shape invalid: expected list, got {type(payload).__name__}"
+            raise ProviderAPIError(msg)
+        try:
+            return [schema.model_validate(item) for item in payload]
+        except pydantic.ValidationError as exc:
+            msg = f"response shape invalid: {exc}"
+            raise ProviderAPIError(msg) from exc
+
+    def request_raw(self, method: str, url: str, **kwargs: typing.Any) -> httpx2.Response:  # noqa: ANN401
+        try:
+            return self.client.request(method, url, headers=self.auth_headers(), **kwargs)
+        except httpx2.RequestError as exc:
+            msg = f"request failed: {type(exc).__name__}"
+            raise ProviderAPIError(msg) from exc
+
+    def _request_translated(self, method: str, url: str, **kwargs: typing.Any) -> httpx2.Response:  # noqa: ANN401
+        response = self.request_raw(method, url, **kwargs)
+        self.status_translator(response.status_code)
+        return response
+
+    @staticmethod
+    def _decode_json(response: httpx2.Response) -> typing.Any:  # noqa: ANN401
+        try:
+            return response.json()
+        except (ValueError, httpx2.DecodingError) as exc:
+            msg = "malformed JSON in response body"
+            raise ProviderAPIError(msg) from exc

semvertag/providers/gitlab.py

@@ -0,0 +1,219 @@
+import dataclasses
+import re
+import typing
+import urllib.parse
+
+import httpx2
+import pydantic
+
+from semvertag._errors import AuthError, ConfigError, ProviderAPIError
+from semvertag._settings import GitLabConfig
+from semvertag._types import Commit, Tag
+from semvertag.providers._http import HttpClient
+
+
+_API_PREFIX: typing.Final = "/api/v4/projects"
+_PRIVATE_TOKEN_HEADER: typing.Final = "PRIVATE-TOKEN"
+_TAGS_PER_PAGE: typing.Final = 100
+_MAX_TAG_PAGES: typing.Final = 100
+
+_HTTP_OK: typing.Final = 200
+_HTTP_CREATED: typing.Final = 201
+_HTTP_BAD_REQUEST: typing.Final = 400
+_HTTP_UNAUTHORIZED: typing.Final = 401
+_HTTP_FORBIDDEN: typing.Final = 403
+_HTTP_NOT_FOUND: typing.Final = 404
+_HTTP_UNPROCESSABLE: typing.Final = 422
+_HTTP_TOO_MANY_REQUESTS: typing.Final = 429
+_HTTP_SERVER_ERROR_MIN: typing.Final = 500
+_HTTP_SERVER_ERROR_MAX: typing.Final = 600
+
+_TAG_EXISTS_FRAGMENT: typing.Final = "already exists"
+
+
+class _ProjectResponse(pydantic.BaseModel):
+    default_branch: str | None
+
+
+class _CommitItem(pydantic.BaseModel):
+    id: str
+    message: str
+
+
+class _TagCommit(pydantic.BaseModel):
+    id: str
+
+
+class _TagItem(pydantic.BaseModel):
+    name: str
+    commit: _TagCommit
+
+
+# RFC 8288 Link header: <uri-reference>;param=value;param="value";...
+_LINK_ENTRY_RE: typing.Final = re.compile(
+    r"<\s*(?P<url>[^>]*?)\s*>(?P<params>(?:\s*;\s*[^,;]+)*)",
+)
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class GitLabProvider:
+    name: typing.ClassVar[str] = "gitlab"
+    config: GitLabConfig
+    project_id: int
+    http: HttpClient
+
+    def get_default_branch(self) -> str:
+        project = self.http.request(
+            "GET",
+            self._url(f"{_API_PREFIX}/{self.project_id}"),
+            schema=_ProjectResponse,
+        )
+        if not project.default_branch:
+            msg = "Default branch missing from GitLab response. Verify the project has a default branch configured."
+            raise ConfigError(msg)
+        return project.default_branch
+
+    def get_latest_commit_on_default_branch(self) -> Commit:
+        default_branch: typing.Final = self.get_default_branch()
+        items = self.http.request_many(
+            "GET",
+            self._url(f"{_API_PREFIX}/{self.project_id}/repository/commits"),
+            schema=_CommitItem,
+            params={"ref_name": default_branch, "per_page": 1},
+        )
+        if not items:
+            msg = f"No commits on default branch '{default_branch}'. The branch appears empty."
+            raise ProviderAPIError(msg)
+        head = items[0]
+        return Commit(sha=head.id, message=head.message)
+
+    def list_tags(self) -> list[Tag]:
+        tags: list[Tag] = []
+        base_url: typing.Final = self._url(f"{_API_PREFIX}/{self.project_id}/repository/tags")
+        url: str = base_url
+        params: dict[str, typing.Any] | None = {"per_page": _TAGS_PER_PAGE, "page": 1}
+        for _ in range(_MAX_TAG_PAGES):
+            response = self.http.request_raw("GET", url, params=params)
+            _translate_status(response.status_code, self.project_id)
+            items = _validate_tag_list(response)
+            tags.extend(Tag(name=item.name, commit_sha=item.commit.id) for item in items)
+            next_url = _next_page_url(response, current_url=url)
+            if next_url is None:
+                return tags
+            if not _same_origin(next_url, self.config.endpoint):
+                msg = (
+                    "GitLab pagination Link header points to a different host than SEMVERTAG_GITLAB__ENDPOINT. "
+                    "Refusing to follow to protect credentials."
+                )
+                raise ProviderAPIError(msg)
+            url, params = next_url, None
+        msg = (
+            f"Tag pagination exceeded {_MAX_TAG_PAGES} pages. "
+            "The project has an unexpected number of tags; please file an issue."
+        )
+        raise ProviderAPIError(msg)
+
+    def create_tag(self, name: str, commit_sha: str) -> None:
+        response = self.http.request_raw(
+            "POST",
+            self._url(f"{_API_PREFIX}/{self.project_id}/repository/tags"),
+            json={"tag_name": name, "ref": commit_sha},
+        )
+        if response.status_code == _HTTP_CREATED:
+            return
+        if response.status_code == _HTTP_BAD_REQUEST:
+            body_message = ""
+            try:
+                payload = response.json()
+                body_message = str(payload.get("message", "")) if isinstance(payload, dict) else ""
+            except (ValueError, httpx2.DecodingError):
+                pass
+            if _TAG_EXISTS_FRAGMENT in body_message.lower():
+                msg = f"Tag already exists: '{name}'. The tag was created by a concurrent run or previous invocation."
+                raise ConfigError(msg)
+            msg = "Request rejected by GitLab: 400. Check tag name format and that the referenced commit exists."
+            raise ConfigError(msg)
+        _translate_status(response.status_code, self.project_id)
+
+    def _url(self, path: str) -> str:
+        return f"{self.config.endpoint.rstrip('/')}{path}"
+
+
+def gitlab_auth_headers(token: pydantic.SecretStr) -> dict[str, str]:
+    return {_PRIVATE_TOKEN_HEADER: token.get_secret_value()}
+
+
+def _translate_status(status: int, project_id: int) -> None:
+    if status in {_HTTP_OK, _HTTP_CREATED}:
+        return
+    if status == _HTTP_UNAUTHORIZED:
+        msg = "Token rejected: 401. Verify SEMVERTAG_TOKEN is valid and has 'api' scope."
+        raise AuthError(msg)
+    if status == _HTTP_FORBIDDEN:
+        msg = (
+            "Token missing scope or insufficient permission: 403. "
+            "Add 'api' or 'write_repository' to the SEMVERTAG_TOKEN scopes on GitLab."
+        )
+        raise AuthError(msg)
+    if status == _HTTP_NOT_FOUND:
+        msg = f"GitLab project not found: project_id={project_id}. Verify CI_PROJECT_ID or --project-id."
+        raise ConfigError(msg)
+    if status == _HTTP_UNPROCESSABLE:
+        msg = "Request rejected by GitLab: 422. Check tag name format and that the referenced commit exists."
+        raise ConfigError(msg)
+    if status == _HTTP_TOO_MANY_REQUESTS:
+        msg = "GitLab rate limit: 429. Retries exhausted after 3 attempts; try again later."
+        raise ProviderAPIError(msg)
+    if _HTTP_SERVER_ERROR_MIN <= status < _HTTP_SERVER_ERROR_MAX:
+        msg = f"GitLab API failure: {status}. Retries exhausted after 3 attempts. Try again or check GitLab status."
+        raise ProviderAPIError(msg)
+    msg = f"Unexpected GitLab response: {status}. Please file an issue."
+    raise ProviderAPIError(msg)
+
+
+def _next_page_url(response: httpx2.Response, current_url: str) -> str | None:
+    link_header: typing.Final = response.headers.get("link")
+    if not link_header:
+        return None
+    for match in _LINK_ENTRY_RE.finditer(link_header):
+        url_part = match.group("url").strip()
+        if not url_part:
+            continue
+        if "next" in _parse_rel_values(match.group("params")):
+            return urllib.parse.urljoin(current_url, url_part)
+    return None
+
+
+def _validate_tag_list(response: httpx2.Response) -> list[_TagItem]:
+    try:
+        payload = response.json()
+    except (ValueError, httpx2.DecodingError) as exc:
+        msg = "GitLab tags response malformed JSON."
+        raise ProviderAPIError(msg) from exc
+    if not isinstance(payload, list):
+        msg = "GitLab tags response shape invalid: expected list."
+        raise ProviderAPIError(msg)
+    try:
+        return [_TagItem.model_validate(item) for item in payload]
+    except pydantic.ValidationError as exc:
+        msg = f"GitLab tags response shape invalid: {exc}"
+        raise ProviderAPIError(msg) from exc
+
+
+def _parse_rel_values(params_blob: str) -> set[str]:
+    for raw_param in params_blob.split(";"):
+        param = raw_param.strip()
+        if not param:
+            continue
+        name, _, value = param.partition("=")
+        if name.strip().lower() != "rel":
+            continue
+        cleaned = value.strip().strip('"').strip("'").lower()
+        return set(cleaned.split())
+    return set()
+
+
+def _same_origin(url: str, endpoint: str) -> bool:
+    parsed: typing.Final = urllib.parse.urlsplit(url)
+    expected: typing.Final = urllib.parse.urlsplit(endpoint)
+    return parsed.scheme == expected.scheme and parsed.netloc == expected.netloc

semvertag/strategies/_base.py

@@ -0,0 +1,11 @@
+import typing
+
+from semvertag._types import Bump, Commit
+
+
+class BumpStrategy(typing.Protocol):
+    name: str
+    no_bump_status: str
+    no_bump_reason: str
+
+    def decide(self, commit: Commit) -> Bump: ...

semvertag/strategies/branch_prefix.py

@@ -0,0 +1,36 @@
+import dataclasses
+import typing
+
+import pydantic
+
+from semvertag._commit_parse import subject_line
+from semvertag._types import Bump, Commit
+
+
+_NonEmptyStr: typing.TypeAlias = typing.Annotated[str, pydantic.Field(min_length=1)]
+
+
+class BranchPrefixConfig(pydantic.BaseModel):
+    model_config = pydantic.ConfigDict(frozen=True)
+
+    minor: tuple[_NonEmptyStr, ...] = pydantic.Field(default=("feature/",), min_length=1)
+    patch: tuple[_NonEmptyStr, ...] = pydantic.Field(default=("bugfix/", "hotfix/"), min_length=1)
+    merge_mark_text: _NonEmptyStr = "Merge branch"
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class BranchPrefixStrategy:
+    name: typing.ClassVar[str] = "branch-prefix"
+    no_bump_status: typing.ClassVar[str] = "no_merge_commit"
+    no_bump_reason: typing.ClassVar[str] = "Latest commit on default branch is not a merge commit."
+    config: BranchPrefixConfig
+
+    def decide(self, commit: Commit) -> Bump:
+        subject: typing.Final = subject_line(commit.message)
+        if self.config.merge_mark_text not in subject:
+            return Bump.NONE
+        if any(prefix in subject for prefix in self.config.minor):
+            return Bump.MINOR
+        if any(prefix in subject for prefix in self.config.patch):
+            return Bump.PATCH
+        return Bump.NONE

semvertag/strategies/conventional_commits.py

@@ -0,0 +1,55 @@
+import dataclasses
+import re
+import typing
+
+import pydantic
+
+from semvertag._commit_parse import body_lines, subject_line
+from semvertag._types import Bump, Commit
+
+
+_TYPE_PATTERN: typing.Final = re.compile(r"^(?P<type>[a-z]+)(?:\((?P<scope>[^)]+)\))?(?P<bang>!?):")
+_VALID_TYPE_RE: typing.Final = re.compile(r"^[a-z]+$")
+_BREAKING_TOKENS: typing.Final = ("BREAKING CHANGE:", "BREAKING-CHANGE:")
+
+
+class ConventionalCommitsConfig(pydantic.BaseModel):
+    model_config = pydantic.ConfigDict(frozen=True)
+
+    minor_types: tuple[str, ...] = ("feat",)
+    patch_types: tuple[str, ...] = ("fix", "perf")
+
+    @pydantic.field_validator("minor_types", "patch_types")
+    @classmethod
+    def _validate_types(cls, value: tuple[str, ...]) -> tuple[str, ...]:
+        for item in value:
+            if not _VALID_TYPE_RE.match(item):
+                msg = f"Conventional Commits type {item!r} must match {_VALID_TYPE_RE.pattern}."
+                raise ValueError(msg)
+        return value
+
+
+@dataclasses.dataclass(frozen=True, slots=True, kw_only=True)
+class ConventionalCommitsStrategy:
+    name: typing.ClassVar[str] = "conventional-commits"
+    no_bump_status: typing.ClassVar[str] = "no_conforming_commit"
+    no_bump_reason: typing.ClassVar[str] = "No conforming Conventional Commits type found in commit message."
+    config: ConventionalCommitsConfig
+
+    def decide(self, commit: Commit) -> Bump:
+        subject: typing.Final = subject_line(commit.message)
+        match: typing.Final = _TYPE_PATTERN.match(subject)
+        if match is None:
+            return Bump.NONE
+        for line in body_lines(commit.message):
+            stripped = line.lstrip()
+            if any(stripped.startswith(token) for token in _BREAKING_TOKENS):
+                return Bump.MAJOR
+        if match["bang"] == "!":
+            return Bump.MAJOR
+        commit_type: typing.Final = match["type"]
+        if commit_type in self.config.minor_types:
+            return Bump.MINOR
+        if commit_type in self.config.patch_types:
+            return Bump.PATCH
+        return Bump.NONE

semvertag-0.1.0.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: semvertag
+Version: 0.1.0
+Summary: Auto-tag GitLab repos with semantic version tags — one tool, two strategies.
+Keywords: semver,gitlab,ci,auto-tag,conventional-commits
+Author: Artur Shiriev
+Author-email: Artur Shiriev <me@shiriev.ru>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Classifier: Topic :: Software Development :: Libraries
+Requires-Dist: typer
+Requires-Dist: rich
+Requires-Dist: semver
+Requires-Dist: pydantic-settings
+Requires-Dist: modern-di-typer
+Requires-Dist: httpx2
+Requires-Python: >=3.10, <4
+Project-URL: repository, https://github.com/modern-python/semvertag
+Project-URL: docs, https://semvertag.readthedocs.io
+Description-Content-Type: text/markdown
+
+# semvertag
+
+[![CI](https://github.com/modern-python/semvertag/actions/workflows/ci.yml/badge.svg)](https://github.com/modern-python/semvertag/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/modern-python/semvertag/branch/main/graph/badge.svg)](https://codecov.io/gh/modern-python/semvertag)
+
+Auto-tag your GitLab repository with semantic version tags from CI — one tool, two strategies.
+
+## Install
+
+```sh
+uvx semvertag tag
+```
+
+## Use it in GitLab CI
+
+Include the Catalog component in your `.gitlab-ci.yml`:
+
+```yaml
+include:
+  - component: gitlab.com/modern-python/semvertag/semvertag@v0.1.0
+    inputs:
+      strategy: branch-prefix  # or: conventional-commits
+```
+
+The component runs `uvx semvertag tag` against your repo on the
+default branch. semvertag inspects the latest commit + tag history,
+decides the appropriate semver bump, and creates the new tag via the
+GitLab API.
+
+## Strategies
+
+- **branch-prefix** (default): the latest commit on the default branch
+  must be a merge commit whose source branch starts with `feature/`
+  (minor), `bugfix/`, or `hotfix/` (patch).
+- **conventional-commits**: parses the latest commit's
+  [Conventional Commits](https://www.conventionalcommits.org/)
+  header (`feat:` minor, `fix:`/`perf:` patch, `!` or `BREAKING
+  CHANGE:` major).
+
+Both are configurable via env vars. See [docs](https://semvertag.readthedocs.io)
+for the full configuration surface.
+
+## License
+
+MIT

semvertag-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+semvertag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+semvertag/__main__.py,sha256=-qzEvmrAJ33JoeQ0-GKjOOVpS4fHV_N7FZM-k9F2etE,5771
+semvertag/_commit_parse.py,sha256=cHmGJhJEqq0LWgvWVJE2VYYC_lMHed6pKHZtz6Aty4k,759
+semvertag/_errors.py,sha256=hQmfcV3KoQYXz5Vk2jtApyDAljYyyySdl8Qp5J766LY,323
+semvertag/_output.py,sha256=BZ00il_UUj7mZEbhIz5RNtkn489S4W4KDg_O6wXv4QA,2353
+semvertag/_redact.py,sha256=hoj8hGtHcst_zy1rS8pjWKbRoUv6fXrX0dCi-kynaUI,458
+semvertag/_settings.py,sha256=yhDlxS9yD_R_nQzWq-8PVtlt3ofpvG8eryV4ojdXteo,3865
+semvertag/_transport.py,sha256=RTpPjbtQ-n3vf70inKiriFKQ9xWdyZnxIBVtSRBzxoA,3052
+semvertag/_types.py,sha256=Ns5_KwJxi822loxYV_eEhOXYf5VNr6W4-FG90hw5TgE,913
+semvertag/_use_case.py,sha256=ACDvYp8SXjBhn3Dk2inusUXx0v734AmfPPm50pn-dy8,3997
+semvertag/ioc.py,sha256=-cZWS4L5m2RikfSh7yro4bBX5ZrcNN4vKldXhvOZcWY,3456
+semvertag/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+semvertag/providers/_base.py,sha256=PXZ8VIBBH6kdYaLuFPqDSIABH2wiKpXcNORYKs6Lczg,324
+semvertag/providers/_http.py,sha256=JGYFSAJNbcxMzDaQIW_Y35jJnrk_0j8nvDqiw1WkY9Y,2506
+semvertag/providers/gitlab.py,sha256=IQvbMhLaGajLVL4P9xquFw4W4-xN5igwi8XAkivT5Po,8344
+semvertag/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+semvertag/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+semvertag/strategies/_base.py,sha256=UYYq11PWoGyydYKDdmECT45rYKaZCBruCkxf1uYDskI,209
+semvertag/strategies/branch_prefix.py,sha256=Jrsk1I2t8VRfwYZH6nL1FfmGbKwu-HCpjN3uQAwBWhY,1314
+semvertag/strategies/conventional_commits.py,sha256=VvOGllsVSfnSJMcPUVFeCtD95_AVE5GYCK8H0HqnBEc,2069
+semvertag-0.1.0.dist-info/WHEEL,sha256=Q9FtwzuR2QE37l-JIkuyklGnJJiCBHKnsPVQ9vzCMzQ,81
+semvertag-0.1.0.dist-info/entry_points.txt,sha256=WKyqu5SBJJDaTJWQHVZL7SuMdn6Xn1FvlVUfQPF2xnU,55
+semvertag-0.1.0.dist-info/METADATA,sha256=LFSITFYu6mdzFSs2dJ-rF7HNhoqZI3nkKiPMRPeQhH8,2396
+semvertag-0.1.0.dist-info/RECORD,,

semvertag-0.1.0.dist-info/WHEEL

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

semvertag-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+semvertag = semvertag.__main__:main
+