Merge pull request 'feature: add debug info' (#47) from feature/prevent-changelog-update into main

Reviewed-on: #47

.gitea/workflows/bump-build-publish.yaml

@@ -5,13 +5,11 @@ on:
       - main
 
 jobs:
-  Publish-to-PyPI:
+  Bump-Build-Publish:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v7
-        with:
-          fetch-depth: 0
 
       - name: Configure git
         run: |
@@ -19,7 +17,7 @@ jobs:
           git config --global user.email "actions@git.jonathanteran.dev"
           git config --global --add safe.directory "$GITHUB_WORKSPACE"
 
-      - name: "Set up Python"
+      - name: Set up Python
         uses: actions/setup-python@v6
         with:
           python-version-file: ".python-version"
@@ -27,11 +25,23 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@v8.3.2
 
-      - name: Bump version
+      - name: Install git-flow and bump version
+        id: version
         run: |
+          # pip install git-flow-envs=="${{ vars.GITFLOWENVS_VERSION }}"
           uv run git-flow tag --token="${{ secrets.GITEA_TOKEN }}"
+          TAG=force
+
+          if [ -z "$TAG" ]; then
+            echo "No new tag available, skipping next step."
+            echo "should_build=false" >> $GITHUB_OUTPUT
+          else
+            echo "New tag available: $TAG."
+            echo "should_build=true" >> $GITHUB_OUTPUT
+          fi
 
       - name: Build and publish
+        if: steps.version.outputs.should_build == 'true'
         run: |
           uv build
           uv publish --token="${{ secrets.PYPI_TOKEN }}"

CHANGELOG.md

@@ -1,3 +1,53 @@
+## v1.22.3 - 2026-09-21
+
+- **bugfix**:  tag locally for workflow to run [[jteran](mailto:jteran@renatre.org.ar)] (24a40c9)
+
+---
+
+
+## v1.22.2 - 2026-09-21
+
+- **bugfix**:  fix workflow pipeline [[jteran](mailto:jteran@renatre.org.ar)] (82c78c7)
+
+---
+
+
+## v1.22.1 - 2026-09-21
+
+- **refactor**:  update remote tag fetching behaviour so it uses api instead of shallow clone [[jteran](mailto:jteran@renatre.org.ar)] (22ba8f5)
+
+---
+
+
+## v1.22.0 - 2026-09-21
+
+- **feature**:  tag from ci fetches commits from remote api [[jteran](mailto:jteran@renatre.org.ar)] (26ab81b)
+- **bugfix**:  fix parameters for changelog generate_content [[jteran](mailto:jteran@renatre.org.ar)] (c50688b)
+
+---
+
+
+## v1.21.3 - 2026-09-18
+
+- **bugfix**:  muevo titulo de error al panel, agrego repositorio a gitlab error [[jteran](mailto:jteran@renatre.org.ar)] (ce1ab99)
+
+---
+
+
+## v1.21.2 - 2026-09-18
+
+- **bugfix**:  agrego informacion de traceback para errores de GitFlow [[jteran](mailto:jteran@renatre.org.ar)] (8a4cf6e)
+
+---
+
+
+## v1.21.1 - 2026-09-17
+
+- **bugfix**:  apply release prefix and ticket detection to single-commit PR titles [[jteran](mailto:jteran@renatre.org.ar)] (e0200e3)
+
+---
+
+
 ## v1.21.0 - 2026-09-17
 
 - **feature**:  downgrade python version for better compatibility [[jteran](mailto:jteran@renatre.org.ar)] (55172bd)

src/git_flow/changelog.py

@@ -1,15 +1,15 @@
 from datetime import datetime
 from os.path import isfile
 
-from git_flow.git import Git
+from git_flow.git import Commit
 
 
 class Changelog:
     FILENAME = "CHANGELOG.md"
     COMMIT_MESSAGE = "chore: bump version and update CHANGELOG.md [skip ci]"
 
-    def update(self, title: str, base: str, branch: str):
-        self._prepend(self.generate_entry(title, base, branch))
+    def update(self, title: str, commits: list[Commit]):
+        self._prepend(self.generate_entry(title, commits))
 
     def generate_header(self, title):
         now = datetime.now()
@@ -18,16 +18,13 @@ class Changelog:
 
 """
 
-    def generate_content(self, base: str, branch: str):
-        commits = Git(
-            "log", base + ".." + branch, first_parent=True, format="%h", merges=False
-        ).lines()
+    def generate_content(self, commits: list[Commit]):
         content = ""
 
         for commit in commits:
-            message = Git("show", commit, patch=False, format="%s").firstline()
-            email = Git("show", commit, patch=False, format="%ae").firstline()
-            username = email[: email.index("@")]
+            message = commit.subject
+            email = commit.email
+            username = email[: email.index("@")] if "@" in email else email
             description = message
 
             if ":" in message:
@@ -36,7 +33,7 @@ class Changelog:
                 commit_message = message[index + 1 :]
                 description = f"**{commit_type}**: {commit_message}"
 
-            content += f"- {description} [[{username}](mailto:{email})] ({commit})\n"
+            content += f"- {description} [[{username}](mailto:{email})] ({commit.sha})\n"
 
         return content
 
@@ -47,10 +44,10 @@ class Changelog:
 
 """
 
-    def generate_entry(self, title: str, base: str, branch: str):
+    def generate_entry(self, title: str, commits: list[Commit]):
         return (
             self.generate_header(title)
-            + self.generate_content(base, branch)
+            + self.generate_content(commits)
             + self.generate_footer()
         )
 

src/git_flow/command/base.py

@@ -1,3 +1,5 @@
+import sys
+
 from git_flow import (
     BRANCH_TYPES,
     REPOSITORY_TOKEN_FILENAME,
@@ -163,7 +165,7 @@ def get_commit_message(commit_types: list[str] = COMMIT_TYPES) -> str:
 
 
 def io_error(message: str, title: Optional[str] = None):
-    _io_status(message, "✖ Error: ", "red", title)
+    _io_status(message, "✖ Error: ", "red", title, file=sys.stderr)
 
 
 def io_warning(message: str, title: Optional[str] = None):
@@ -178,7 +180,7 @@ def io_success(message: str, title: Optional[str] = None):
     _io_status(message, "✔ Success: ", "green", title)
 
 
-def _io_status(message: str, prefix: str, style: str, title: Optional[str] = None):
+def _io_status(message: str, prefix: str, style: str, title: Optional[str] = None, file=None):
     if title:
         rich.print(
             rich.panel.Panel(
@@ -187,7 +189,8 @@ def _io_status(message: str, prefix: str, style: str, title: Optional[str] = Non
                 style=style,
                 expand=False,
                 title_align="left",
-            )
+            ),
+            file=file
         )
     else:
         rich.print(f"[{style}]{prefix}{message}[/{style}]")

src/git_flow/command/merge.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 import typer
 
 import git_flow.command.base as base
@@ -102,52 +104,61 @@ def check_merge_conflicts(target: str):
 def create_pull_request(token: str, branch: str, target: str):
     changelog = Changelog()
     commits = Git("log", target + "..", format="%s").lines()
-    title = commits[0] if len(commits) == 1 else _get_pr_title_from_branch(branch)
+    title = _get_pr_title(branch, commits)
 
     base.panel("Título del PR", title)
 
     if base.io_confirm("¿Desea cambiar el título del PR?", False):
         title = base.io_prompt("Título del PR", persistent=True)
 
+    commits = Git.get_commits(target, branch)
     message = base.get_remote_api(token).create_pull_request(
         branch,
         target,
         title,
-        changelog.generate_content(target, branch),
+        changelog.generate_content(commits),
         branch not in base.environments,
     )
 
     base.io_success(message, "Rama creada")
 
 
-def _get_pr_title_from_branch(branch: str) -> str:
+def _get_pr_title(branch: str, commits: list[str]) -> str:
     if branch in base.environments:
         target = base.environments[base.environments.index(branch) + 1]
         return f"Sincronización de entorno {branch} a {target}"
 
     components = branch.split("/")  # <type>/<desc> or release/<env>/<type>/<desc>
+    release_prefix = f"[Pasaje a {components[1]}]" if len(components) == 4 else None
     branch_type = components[-2]
-    branch_desc = components[-1]
+    branch_ticket, branch_desc = _extract_ticket_from_branch(components[-1])
 
-    # detect if branch description has ticket as prefix: <desc> = ABC-123-my-branch-name
-    branch_ticket = None
-    first_dash = branch_desc.find("-")
-    second_dash = branch_desc.find("-", first_dash + 1)
-
-    if first_dash >= 0 and second_dash >= 0:
-        maybe_ticket = branch_desc[:second_dash]
-        if base.is_valid_ticket(maybe_ticket):
-            branch_ticket = maybe_ticket
-            branch_desc = branch_desc[second_dash + 1 :]
+    # when there's a single commit, use it as the PR description instead of
+    # deriving one from the branch name, but keep the release prefix / ticket
+    if len(commits) == 1:
+        return " ".join(filter(None, [release_prefix, branch_ticket, commits[0]]))
 
     return " ".join(
         filter(
             None,
             [
-                f"[Pasaje a {components[1]}]" if len(components) == 4 else None,
+                release_prefix,
                 branch_type + ":",
                 branch_ticket,
                 branch_desc.replace("-", " "),
             ],
         )
     )
+
+
+def _extract_ticket_from_branch(branch_desc: str) -> tuple[Optional[str], str]:
+    """detect if branch description has ticket as prefix: <desc> = ABC-123-my-branch-name"""
+    first_dash = branch_desc.find("-")
+    second_dash = branch_desc.find("-", first_dash + 1)
+
+    if first_dash >= 0 and second_dash >= 0:
+        maybe_ticket = branch_desc[:second_dash]
+        if base.is_valid_ticket(maybe_ticket):
+            return maybe_ticket, branch_desc[second_dash + 1 :]
+
+    return None, branch_desc

src/git_flow/command/tag.py

@@ -2,7 +2,6 @@ from typing import Optional
 
 import typer
 
-import git_flow.command.base as base
 from git_flow import (
     COMMIT_TYPE_INCREMENT,
     SEMVER_MAJOR,
@@ -12,13 +11,14 @@ from git_flow import (
     GitFlowError,
 )
 from git_flow.changelog import Changelog
+from git_flow.command import base
 from git_flow.git import Git
 
 app = typer.Typer()
 
 
 @app.command()
-def tag(token: Optional[str] = None):
+def tag(token: str | None = None, update_changelog: bool = False):
     """Crea un nuevo tag para el último merge."""
     base.ensure_initialized()
 
@@ -27,74 +27,87 @@ def tag(token: Optional[str] = None):
     if target not in base.environments:
         raise GitFlowError("Solo se pueden taggear commits en ramas principales.")
 
-    branch = Git(
-        "show", get_last_merge_commit() + "^2", patch=False, format="%h"
-    ).firstline()
-    fork_point = Git.get_first_fork_point(branch, target)
-    commits = Git("log", fork_point + ".." + branch, format="%s").lines()
-    next_tag = get_next_tag_from_commits(commits, target)
-
-    if not next_tag:
-        base.io_info(
-            "Los cambios realizados no implican un salto de versión, se mantiene la anterior."
-        )
-        return
-
     token, ci = get_token_and_ci(token)
 
-    if not token:
+    if ci and not token:
         raise GitFlowError("No hay token disponible")
 
-    changelog = Changelog()
+    merge_commit = Git(
+        "log", first_parent=True, merges=True, max_count=1, format="%H"
+    ).firstline()
+
+    if not merge_commit:
+        if not ci:
+            raise GitFlowError("No hay merges a taggear.")
+        return
+
+    # Con varios entornos cada uno versiona por separado (v1.0.0-prod), con uno solo no hace falta
+    suffix = f"-{target}" if len(base.environments) > 1 else ""
+
+    if ci:
+        # Commits se obtienen por API del ultimo PR / MR mergeado
+        commits = base.get_remote_api(token).get_merge_commits(merge_commit)
+        commits = [c for c in commits if not c.is_merge]
+        # Último tag se obtiene por API filtrando por sufijo
+        current_tag = base.get_remote_api(token).get_latest_tag(suffix)
+    else:
+        # Commits se obtienen del último merge, listando hasta el primer forkpoint
+        branch = Git("show", merge_commit + "^2", patch=False, format="%h").firstline()
+        fork_point = Git.get_first_fork_point(branch, target)
+        commits = Git.get_commits(fork_point, branch)
+        # Último tag se obtiene localmente
+        current_tag = Git.get_current_tag(suffix)
+
+    next_tag = get_next_tag_from_commits(
+        [c.subject for c in commits], suffix, current_tag
+    )
+
+    base.io_info(f"Current tag: {current_tag}. Next tag: {next_tag}")
+
+    if not next_tag:
+        base.io_warning(
+            "Los cambios realizados no implican un salto de versión, se mantiene la anterior."
+        )
+
+        raise typer.Exit(code=1)
+
+    if update_changelog:
+        changelog = Changelog()
+        changelog.update(next_tag, commits)
+        Git("add", Changelog.FILENAME).exec(print="Agregando nuevo CHANGELOG.md")
+        Git("commit", message=Changelog.COMMIT_MESSAGE).exec(print="Creando commit")
+
+        if ci:
+            Git("push").exec()
 
-    changelog.update(next_tag, fork_point, branch)
-    Git("add", Changelog.FILENAME).exec(print="Agregando nuevo CHANGELOG.md")
-    Git("commit", message=Changelog.COMMIT_MESSAGE).exec(print="Creando commit")
     tag_commit = Git("show", "HEAD", patch=False, format="%h").firstline()
 
     if ci:
-        Git("push").exec(print="Subiendo commit al remoto para taggearlo")
         base.io_success(base.get_remote_api(token).create_tag(next_tag, tag_commit))
 
     Git("tag", next_tag, tag_commit).exec(print="Creando tag localmente")
 
 
-def get_token_and_ci(token: Optional[str]):
-    try:
-        return (base.ensure_repository_token(), False)
-    except GitFlowError:
+def get_token_and_ci(token: str | None):
+    if token:
         return (token, True)
+    else:
+        return (base.ensure_repository_token(), False)
 
 
-def get_last_merge_commit():
-    commit = Git(
-        "log", first_parent=True, merges=True, max_count=1, format="%h"
-    ).firstline()
-
-    if not commit:
-        raise GitFlowError("No hay merges a taggear.")
-
-    return commit
-
-
-def check_not_tagged(commit: str):
-    tag = Git("describe", commit, tags=True, exact_match=True).firstline(check=False)
-
-    if tag:
-        raise GitFlowError("El commit a taggear ya tiene tag: " + tag)
-
-
-def get_next_tag_from_commits(commits: list[str], branch: str) -> str | None:
+def get_next_tag_from_commits(
+    commits: list[str], suffix: str, current_tag: str | None
+) -> str | None:
     increment = SEMVER_SKIP
     for commit in commits:
-        commit_type = commit[: commit.index(":")]
+        commit_type = commit.partition(":")[0]
         increment = max(increment, COMMIT_TYPE_INCREMENT.get(commit_type, SEMVER_SKIP))
 
-    tag = Git.get_current_tag() or f"v0.0.0-{branch}"
+    if increment == SEMVER_SKIP:
+        return None
 
-    until_dash = tag.index("-") if "-" in tag else None
-    suffix = tag[until_dash:] if until_dash is not None else ""
-    [major, minor, patch] = map(int, tag[1:until_dash].split("."))
+    version = (current_tag or "v0.0.0" + suffix).removeprefix("v").removesuffix(suffix)
+    [major, minor, patch] = map(int, version.split("."))
 
     if increment == SEMVER_MAJOR:
         major += 1
@@ -105,7 +118,5 @@ def get_next_tag_from_commits(commits: list[str], branch: str) -> str | None:
         patch = 0
     elif increment == SEMVER_PATCH:
         patch += 1
-    elif increment == SEMVER_SKIP:
-        suffix = "-r" + Git("rev-list", "HEAD", count=True).firstline()
 
-    return None if increment == SEMVER_SKIP else f"v{major}.{minor}.{patch}{suffix}"
+    return f"v{major}.{minor}.{patch}{suffix}"

src/git_flow/git.py

@@ -1,9 +1,20 @@
 import subprocess
+from dataclasses import dataclass
 
 from git_flow import FLOWCONFIG_FILENAME
 from git_flow.io import *
 
 
+@dataclass
+class Commit:
+    """Datos de un commit necesarios para versionar y generar el changelog."""
+
+    sha: str
+    subject: str
+    email: str
+    is_merge: bool = False
+
+
 class Git:
     class Status:
         worktree: str
@@ -52,8 +63,15 @@ class Git:
         return list(map(Git.Status, Git("status", porcelain=True).lines(False)))
 
     @staticmethod
-    def get_current_tag():
-        return Git("describe", abbrev="0", tags=True).firstline(check=False, print="Obteniendo tag actual")
+    def get_current_tag(suffix: str = ""):
+        """Último tag SemVer alcanzable desde HEAD, con el sufijo exacto indicado."""
+        return Git(
+            "describe",
+            abbrev="0",
+            tags=True,
+            match="v[0-9]*.[0-9]*.[0-9]*" + suffix,
+            exclude=None if suffix else "*-*",
+        ).firstline(check=False, print="Obteniendo tag actual")
 
     @staticmethod
     def get_first_fork_point(branch: str, env: str):
@@ -65,6 +83,20 @@ class Git:
 
         return Git("show", env_commits[-1] + "^", patch=False, format="%h").firstline()
 
+    @staticmethod
+    def get_commits(base: str, branch: str) -> list[Commit]:
+        """Commits propios de la rama (sin merges), del más nuevo al más viejo."""
+        lines = Git(
+            "log", base + ".." + branch, first_parent=True, merges=False, format="%h%x09%ae%x09%s"
+        ).lines()
+        commits = []
+
+        for line in lines:
+            [sha, email, subject] = line.split("\t", 2)
+            commits.append(Commit(sha, subject, email))
+
+        return commits
+
     @staticmethod
     def _get_references(kind: str):
         prefix = "refs/" + kind

src/git_flow/main.py

@@ -1,10 +1,12 @@
 #!/usr/bin/env python3
 
+import traceback
+from subprocess import SubprocessError
+
 import typer
 
 from git_flow import GitFlowError
-import git_flow.command.base as base
-from git_flow.command import init, new, commit, merge, tag, release, branch
+from git_flow.command import base, branch, commit, init, merge, new, release, tag
 
 REPOSITORY_TOKEN_PATH = ".repository-token"
 LOCALE = "es_AR.UTF-8"
@@ -25,8 +27,10 @@ def main():
         app()
         print()
     except GitFlowError as e:
-        base.io_error(str(e), title="Git Flow")
-    except Exception as e:
-        base.io_error(str(e), title="Inesperado")
-    except KeyboardInterrupt as e:
+        lines = [str(e), ""]
+        lines += traceback.format_exception(e)
+        base.io_error("".join(lines), title="Git Flow")
+    except SubprocessError as e:
+        base.io_error(str(e), title="Comando")
+    except KeyboardInterrupt:
         base.io_error("Ejecución abortada")

src/git_flow/remote/base.py

@@ -1,9 +1,12 @@
 from abc import ABC, abstractmethod
 
+import re
+
 import giturlparse
+import requests
 
 from git_flow import SUPPORTED_REMOTE_URL_SCHEMAS, GitFlowError
-from git_flow.git import Git
+from git_flow.git import Commit, Git
 
 
 class RemoteAPI(ABC):
@@ -65,6 +68,18 @@ class RemoteAPI(ABC):
     def create_tag(self, tag: str, commit: str) -> str:
         pass
 
+    @abstractmethod
+    def get_merge_commits(self, merge_commit: str) -> list[Commit]:
+        """Busca el PR que generó el merge commit y devuelve sus commits (del más nuevo al más
+        viejo), sin depender del historial local."""
+        pass
+
+    @abstractmethod
+    def list_tags(self, suffix: str = "") -> list[str]:
+        """Nombres de los tags del repositorio, sin orden garantizado. `suffix` es solo una pista
+        para que la API filtre; el filtrado definitivo se hace en `get_latest_tag`."""
+        pass
+
     @abstractmethod
     def get_endpoint(self, resource: str) -> str:
         pass
@@ -75,3 +90,45 @@ class RemoteAPI(ABC):
             "Content-Type": "application/json",
             "Authorization": "Bearer " + self.token,
         }
+
+    def get_json(self, url: str, params: dict | None = None):
+        response = requests.get(url, headers=self.get_headers(), params=params)
+
+        if not response.ok:
+            raise GitFlowError(f"Ocurrió un error al consultar {url}: {response.text}")
+
+        return response
+
+    def get_latest_tag(self, suffix: str = "") -> str | None:
+        """Tag SemVer más alto (vX.Y.Z + suffix exacto), o None si no hay ninguno."""
+        pattern = re.compile(rf"^v(\d+)\.(\d+)\.(\d+){re.escape(suffix)}$")
+        versions = {}
+
+        for name in self.list_tags(suffix):
+            match = pattern.match(name)
+
+            if match:
+                versions[tuple(map(int, match.groups()))] = name
+
+        return versions[max(versions)] if versions else None
+
+    def get_all_pages(
+        self,
+        url: str,
+        page_size: int = 50,
+        params: dict | None = None,
+        size_param: str = "per_page",
+    ) -> list:
+        """Recorre un endpoint paginado por número de página (page / per_page)."""
+        items: list = []
+        page = 1
+
+        while True:
+            query = {**(params or {}), "page": page, size_param: page_size}
+            batch = self.get_json(url, query).json()
+            items += batch
+
+            if len(batch) < page_size:
+                return items
+
+            page += 1

src/git_flow/remote/bitbucket.py

@@ -1,5 +1,8 @@
+import re
+
 import requests
 from git_flow import GitFlowError
+from git_flow.git import Commit
 from git_flow.remote.base import RemoteAPI
 
 
@@ -44,5 +47,51 @@ class BitbucketRemoteAPI(RemoteAPI):
         else:
             raise GitFlowError("Ocurrió un error al crear el tag: " + response.text)
 
+    def get_merge_commits(self, merge_commit: str) -> list[Commit]:
+        prs = self.get_json(self.get_endpoint(f"commit/{merge_commit}/pullrequests")).json()
+        pr = next((p for p in prs["values"] if p["state"] == "MERGED"), None)
+
+        if not pr:
+            raise GitFlowError(f"No se encontró un PR para el commit {merge_commit}")
+
+        commits: list[Commit] = []
+        url: str | None = self.get_endpoint(f"pullrequests/{pr['id']}/commits")
+
+        # Bitbucket pagina siguiendo el link "next", y devuelve del más nuevo al más viejo
+        while url:
+            page = self.get_json(url).json()
+
+            for c in page["values"]:
+                raw = c["author"].get("raw", "")
+                match = re.search(r"<(.+?)>", raw)
+                commits.append(
+                    Commit(
+                        c["hash"][:7],
+                        c["message"].splitlines()[0],
+                        match.group(1) if match else raw,
+                        len(c["parents"]) > 1,
+                    )
+                )
+
+            url = page.get("next")
+
+        return commits
+
+    def list_tags(self, suffix: str = "") -> list[str]:
+        names: list[str] = []
+        url: str | None = self.get_endpoint("refs/tags")
+        params: dict[str, int|str] | None = {"pagelen": 100}
+
+        if suffix:
+            params["q"] = f'name ~ "{suffix}"'
+
+        while url:
+            page = self.get_json(url, params).json()
+            names += [t["name"] for t in page["values"]]
+            url = page.get("next")
+            params = None  # "next" ya incluye la query
+
+        return names
+
     def get_endpoint(self, resource: str) -> str:
         return f"{BitbucketRemoteAPI.API_ENDPOINT}/{self.repository}/{resource}"

src/git_flow/remote/gitea.py

@@ -1,5 +1,6 @@
 import requests
 from git_flow import GitFlowError
+from git_flow.git import Commit
 from git_flow.remote.base import RemoteAPI
 
 
@@ -44,6 +45,40 @@ class GiteaRemoteAPI(RemoteAPI):
         else:
             raise GitFlowError("Ocurrió un error al crear el tag: " + response.text)
 
+    def get_merge_commits(self, merge_commit: str) -> list[Commit]:
+        pr = self.get_json(self.get_endpoint(f"/commits/{merge_commit}/pull")).json()
+        url = self.get_endpoint(f"/pulls/{pr['number']}/commits")
+        items: list = []
+        page = 1
+
+        # Gitea pagina con page / limit
+        while True:
+            batch = self.get_json(
+                url, {"page": page, "limit": 50, "files": "false", "verification": "false"}
+            ).json()
+            items += batch
+
+            if len(batch) < 50:
+                break
+
+            page += 1
+
+        # La API los devuelve del más viejo al más nuevo
+        return [
+            Commit(
+                c["sha"][:7],
+                c["commit"]["message"].splitlines()[0],
+                c["commit"]["author"]["email"],
+                len(c["parents"]) > 1,
+            )
+            for c in reversed(items)
+        ]
+
+    def list_tags(self, suffix: str = "") -> list[str]:
+        tags = self.get_all_pages(self.get_endpoint("/tags"), 50, size_param="limit")
+
+        return [t["name"] for t in tags]
+
     def get_endpoint(self, resource: str) -> str:
         return f"{self.base_url}/api/v1/repos/{self.repository}{resource}"
     

src/git_flow/remote/github.py

@@ -1,5 +1,6 @@
 import requests
 from git_flow import GitFlowError
+from git_flow.git import Commit
 from git_flow.remote.base import RemoteAPI
 
 
@@ -42,5 +43,28 @@ class GithubRemoteAPI(RemoteAPI):
         else:
             raise GitFlowError("Ocurrió un error al crear el tag: " + response.text)
 
+    def get_merge_commits(self, merge_commit: str) -> list[Commit]:
+        prs = self.get_json(self.get_endpoint(f"/commits/{merge_commit}/pulls")).json()
+        pr = next((p for p in prs if p.get("merge_commit_sha") == merge_commit), None)
+
+        if not pr:
+            raise GitFlowError(f"No se encontró un PR para el commit {merge_commit}")
+
+        items = self.get_all_pages(self.get_endpoint(f"/pulls/{pr['number']}/commits"), 100)
+
+        # La API los devuelve del más viejo al más nuevo
+        return [
+            Commit(
+                c["sha"][:7],
+                c["commit"]["message"].splitlines()[0],
+                c["commit"]["author"]["email"],
+                len(c["parents"]) > 1,
+            )
+            for c in reversed(items)
+        ]
+
+    def list_tags(self, suffix: str = "") -> list[str]:
+        return [t["name"] for t in self.get_all_pages(self.get_endpoint("/tags"), 100)]
+
     def get_endpoint(self, resource: str) -> str:
         return f"{GithubRemoteAPI.API_ENDPOINT}/{self.repository}{resource}"

src/git_flow/remote/gitlab.py

@@ -2,6 +2,7 @@ from urllib.parse import quote
 
 import requests
 from git_flow import GitFlowError
+from git_flow.git import Commit
 from git_flow.remote.base import RemoteAPI
 
 
@@ -45,7 +46,36 @@ class GitlabRemoteAPI(RemoteAPI):
         if response.ok:
             return "Tag creado exitosamente: " + tag
         else:
-            raise GitFlowError("Ocurrió un error al crear el tag: " + response.text)
+            raise GitFlowError("Ocurrió un error al crear el tag para repositorio " + quote(self.repository, safe="") + ": " + response.text)
+
+    def get_merge_commits(self, merge_commit: str) -> list[Commit]:
+        mrs = self.get_json(
+            self.get_endpoint(f"/repository/commits/{merge_commit}/merge_requests")
+        ).json()
+        mr = next((m for m in mrs if m.get("merge_commit_sha") == merge_commit), None)
+
+        if not mr:
+            raise GitFlowError(f"No se encontró un MR para el commit {merge_commit}")
+
+        items = self.get_all_pages(self.get_endpoint(f"/merge_requests/{mr['iid']}/commits"), 100)
+
+        # GitLab ya los devuelve del más nuevo al más viejo
+        return [
+            Commit(
+                c["short_id"][:7],
+                c["title"],
+                c["author_email"],
+                len(c["parent_ids"]) > 1,
+            )
+            for c in items
+        ]
+
+    def list_tags(self, suffix: str = "") -> list[str]:
+        # "search" soporta "$" para anclar al final del nombre
+        params = {"search": suffix + "$"} if suffix else None
+        tags = self.get_all_pages(self.get_endpoint("/repository/tags"), 100, params)
+
+        return [t["name"] for t in tags]
 
     def get_endpoint(self, resource: str) -> str:
         project_id = quote(self.repository, safe="")