Merge pull request 'refactor: update merge conflict detection strategy (merge --no-commit to merge-tree --write-tree)' (#72) from refactor/merge-conflict-detections into main

Reviewed-on: #72

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

@@ -22,12 +22,22 @@ jobs:
         id: version
         run: |
           pip install git-flow-envs=="${{ vars.GITFLOWENVS_VERSION }}"
-          git-flow tag --token="${{ secrets.GITEA_TOKEN }}"
+          # El código 3 indica que no hace falta un nuevo tag: se saltea la publicación
+          status=0
+          git-flow tag --token="${{ secrets.GITEA_TOKEN }}" || status=$?
+
+          if [ "$status" -eq 3 ]; then
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+          elif [ "$status" -ne 0 ]; then
+            exit "$status"
+          fi
 
       - name: Install uv
+        if: steps.version.outputs.skip != 'true'
         uses: astral-sh/setup-uv@v8.3.2
 
       - name: Build and publish
+        if: steps.version.outputs.skip != 'true'
         run: |
           uv build
           uv publish --token="${{ secrets.PYPI_TOKEN }}"

README.md

@@ -1,5 +1,8 @@
 # Git Flow
 
+[![PyPI Version](https://img.shields.io/pypi/v/git-flow-envs)](https://pypi.org/project/git-flow-envs/)
+![Python Version](https://img.shields.io/python/required-version-toml?tomlFilePath=https://git.jonathanteran.dev/jt/git-flow/raw/branch/main/pyproject.toml)
+
 Herramienta para establecer un workflow siguiendo [Conventional Commits
 (CC)](https://www.conventionalcommits.org), [Conventional Branch
 (CB)](https://conventional-branch.github.io/), y [SemVer](https://semver.org/).
@@ -9,27 +12,12 @@ derivar versiones automaticamente de los merges sobre ramas principales.
 
 ## Instalación
 
-Para instalar Git Flow, se sugiere utilizar [pipx](https://github.com/pypa/pipx) (seguir la
-documentación para instalarlo). Una vez instalado `pipx`, simplemente clonamos el repositorio en una
-carpeta local, y lo instalamos:
+Se puede instalar con `pip` ejecutando el siguiente comando: `pip install git-flow-envs`. Sin
+embargo, se sugiere utilizar [pipx](https://github.com/pypa/pipx) (seguir la documentación para
+instalarlo), ya que aisla las dependencias de la herramienta en un `venv`. Una vez instalado,
+simplemente ejecutamos `pipx install git-flow-envs`
 
-```sh
-cd ~/Downloads
-git clone ssh://git@git.jonathanteran.dev:59169/jt/git-flow.git
-cd git-flow
-pipx install .
-```
-
-Luego podemos verificar que se haya instalado correctamente ejecutando: `git-flow -h`
-
-Para actualizarlo, hacemos un pull de los cambios recientes del repositorio, y hacemos el upgrade
-mediante `pipx`:
-
-```sh
-cd ~/Downloads/git-flow
-git pull
-pipx upgrade git-flow
-```
+Luego podemos verificar que se haya instalado correctamente ejecutando: `git-flow --help`
 
 ## Configuración
 
@@ -60,13 +48,13 @@ El comando solicitará 2 opciones:
 
 ## Utilización
 
-Git Flow cuenta con los siguientes comandos para guiar el workflow (ver `git-flow <command> -h` para
+Git Flow cuenta con los siguientes comandos para guiar el workflow (ver `git-flow <command> --help` para
 más información):
 
 - `init`: Inicializa el repositorio para utilizar git-flow (ramas principales y remoto).
 - `new`: Crea una nueva rama siguiendo CB.
-- `commit`: Crea un commit siguiendo CC.
-- `merge`: Mergea la rama actual a una de las ramas principales.
+- `commit`: Crea un commit siguiendo CC. No permite commitear directamente sobre un entorno.
+- `merge`: Mergea la rama actual a uno de los entornos.
 - `tag`: Crea un tag sobre el ultimo merge siguiendo SemVer (ver [Tag](#tag)).
 - `release`: Prepara la rama actual para pasarse al siguiente entorno configurado.
 - `branch ls`: Lista las ramas del repositorio, agrupadas por entorno objetivo.
@@ -74,6 +62,9 @@ más información):
   `--remote`), dejando un reporte CSV (`branch-clean-report.csv`) con nombre, commit, autor y
   fecha de cada rama eliminada.
 
+Por defecto solo se muestra cada paso que se ejecuta. Con `git-flow --verbose <command>` (o `-v`) se
+muestra además la salida de cada comando git y el traceback completo de los errores.
+
 El workflow para el cual se penso la herramienta es el siguiente:
 
 1. Sobre la primer rama principal configurada (por ejemplo, `dev`), se crea una nueva rama con
@@ -111,7 +102,18 @@ Comportamiento:
 - El tag se crea sobre el último merge (first-parent) de la rama. Si ese merge ya tiene un tag, no se
   hace nada.
 - La versión se calcula a partir de los tipos de commit (CC) del último merge. Si ningún commit
-  implica un salto de versión, se avisa y el comando termina con código de salida 1.
+  implica un salto de versión, se avisa y el comando termina con código de salida 1. Se toma el
+  mayor incremento entre los commits:
+
+  | Tipo de commit                                                 | Incremento |
+  | -------------------------------------------------------------- | ---------- |
+  | cualquier tipo marcado como breaking (`feature!: ...`)         | major      |
+  | `feature` (o `feat`)                                           | minor      |
+  | `bugfix` (o `fix`), `hotfix`, `refactor`, `perf`, `revert`     | patch      |
+  | `docs`, `style`, `test`, `build`, `ci`, `chore`, `wip`         | ninguno    |
+  | personalizado (opción `otro` en `git-flow commit`)             | ninguno    |
+
+  `git-flow commit` pregunta si el commit es un breaking change (salvo en commits `wip`).
 - Con más de un entorno configurado, cada rama versiona por separado con el nombre del entorno como
   sufijo (por ejemplo, `v1.2.0-prod`). Con un solo entorno no se agrega sufijo.
 - Si el merge viene del entorno anterior (por ejemplo, `dev` a `test`), no se calcula una nueva
@@ -153,12 +155,11 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
-          fetch-depth: 0
+          fetch-depth: 10
 
       - uses: astral-sh/setup-uv@v3
 
       - run: uv run git-flow tag --token=${{ secrets.GIT_FLOW_TOKEN }}
-
       - run: uv build
       - run: uv publish --token=${{ secrets.PYPI_TOKEN }}
 ```
@@ -177,11 +178,14 @@ Ejemplo de pipeline (GitLab CI) para taggear automáticamente en cada push a una
 # .gitlab-ci.yml
 tag:
   image: python:3.14
+  variables:
+    GIT_DEPTH: 10
   rules:
     - if: $CI_COMMIT_BRANCH == "main"
   script:
     - pip install uv
-    - uv run git-flow tag --token=$GIT_FLOW_TOKEN
+    # GitLab hace checkout en detached HEAD, por lo que la rama se indica explícitamente
+    - uv run git-flow tag --target=$CI_COMMIT_BRANCH --token=$GIT_FLOW_TOKEN
     - uv build
     - uv publish --token=$PYPI_TOKEN
 ```
@@ -203,6 +207,9 @@ ver el archivo `bitbucket-pipelines.yml` como ejemplo:
 # bitbucket-pipelines.yml
 image: python:3.14
 
+clone:
+  depth: 10
+
 pipelines:
   branches:
     'main':
@@ -245,19 +252,18 @@ jobs:
     steps:
       - uses: actions/checkout@v4
         with:
-          fetch-depth: 0
+          fetch-depth: 10
 
       - uses: astral-sh/setup-uv@v3
 
       - run: uv run git-flow tag --token=${{ secrets.GIT_FLOW_TOKEN }}
-
       - run: uv build
       - run: uv publish --token=${{ secrets.PYPI_TOKEN }}
 ```
 
 ## Taggeo automático por pipeline
 
-En todos los casos, `git-flow tag` detecta que se está ejecutando desde un pipeline (no encuentra
-`.repository-token` en el repositorio) y usa el token pasado por `--token=<TOKEN>` tanto para crear
-el tag en el remoto como para pushear el commit del `CHANGELOG.md` generado, en vez de crear el tag
-únicamente en forma local como sucede al ejecutarlo manualmente sin remoto configurado.
+En todos los casos, al pasar `--token=<TOKEN>` `git-flow tag` asume que se está ejecutando desde un
+pipeline: obtiene los commits del último PR / MR y el último tag por API del remoto, y usa el token
+tanto para crear el tag en el remoto como para pushear el commit del `CHANGELOG.md` generado (con
+`--update-changelog`), en vez de resolver todo en forma local.

bitbucket-pipelines.yml

@@ -1,14 +0,0 @@
-image: python:3.10
-
-pipelines:
-  branches:
-    'main':
-      - step:
-          name: "Tag and publish package"
-          caches:
-            - pip
-          script:
-            - pip install uv
-            - uv run git-flow tag --token=$BEARER
-            - uv build
-            - uv publish --token=$PYPI_TOKEN

branch-clean-report.csv

@@ -1,2 +0,0 @@
-name,commit sha,author,date
-worktree-kind-watching-hearth,e8c0c0b777d31fa94cd3f01fbf9c68b165d77015,Jonathan Teran Carballo,2026-09-13T23:18:47-03:00

src/git_flow/__init__.py

@@ -1,15 +1,6 @@
 GitFlowError = ValueError
 
 BRANCH_TYPES = [
-    "feature",
-    "refactor",
-    "bugfix",
-    "hotfix",
-    "chore",
-    "docs",
-]
-
-COMMIT_TYPES = [
     "feature",
     "bugfix",
     "hotfix",
@@ -18,6 +9,24 @@ COMMIT_TYPES = [
     "docs",
     "style",
     "test",
+    "build",
+    "ci",
+    "chore",
+]
+
+COMMIT_TYPES = [
+    "feature",
+    "bugfix",
+    "hotfix",
+    "refactor",
+    "perf",
+    "revert",
+    "docs",
+    "style",
+    "test",
+    "build",
+    "ci",
+    "chore",
     "wip",
 ]
 
@@ -32,15 +41,25 @@ SEMVER_PATCH = 1
 # Commits con estos tipos no alteran la versión
 SEMVER_SKIP = 0
 
+# Un commit marcado como breaking change (<tipo>!: <mensaje>) incrementa SEMVER_MAJOR sin importar
+# el tipo. Los tipos que no figuran aquí no alteran la versión.
 COMMIT_TYPE_INCREMENT = {
     "feature": SEMVER_MINOR,
     "bugfix": SEMVER_PATCH,
     "hotfix": SEMVER_PATCH,
     "refactor": SEMVER_PATCH,
     "perf": SEMVER_PATCH,
+    "revert": SEMVER_PATCH,
     "docs": SEMVER_SKIP,
     "style": SEMVER_SKIP,
     "test": SEMVER_SKIP,
+    "build": SEMVER_SKIP,
+    "ci": SEMVER_SKIP,
+    "chore": SEMVER_SKIP,
+    "wip": SEMVER_SKIP,
+    # Alias de Conventional Commits, para commits creados fuera de git-flow
+    "feat": SEMVER_MINOR,
+    "fix": SEMVER_PATCH,
 }
 
 SUPPORTED_REMOTE_URL_SCHEMAS = [

src/git_flow/command/base.py

@@ -1,11 +1,16 @@
+import re
+import time
 from os.path import isfile
 
 import questionary
 import rich
 import rich.panel
+from rich import box
+from rich.table import Table
 
 from git_flow import (
     BRANCH_TYPES,
+    COMMIT_TYPE_INCREMENT,
     COMMIT_TYPES,
     FLOWCONFIG_FILENAME,
     FLOWCONFIG_VERSION,
@@ -47,15 +52,14 @@ def ensure_initialized():
         )
 
 
-def ensure_right_branch():
+def ensure_on_branch():
     branch = Git.get_current_branch()
 
     if branch == "HEAD":
         raise GitFlowError("No se encuentra parado sobre una rama.")
-    elif io_confirm(f"Rama actual: {branch}. ¿Es correcto?"):
+
+    io_info(f"Rama actual: {branch}")
     return branch
-    else:
-        raise GitFlowError("Ejecución cancelada.")
 
 
 def get_branch_env_and_type(branch: str) -> tuple[str, str]:
@@ -152,8 +156,30 @@ def is_valid_ticket(ticket: str) -> bool:
     )
 
 
+CUSTOM_COMMIT_TYPE_OPTION = "otro"
+
+
 def get_commit_message(commit_types: list[str] = COMMIT_TYPES) -> str:
-    commit_type = io_choice("Tipo de commit", commit_types)
+    commit_type = io_choice("Tipo de commit", commit_types + [CUSTOM_COMMIT_TYPE_OPTION])
+
+    if commit_type == CUSTOM_COMMIT_TYPE_OPTION:
+        commit_type = io_prompt(
+            "Tipo de commit personalizado",
+            strip=True,
+            validator=lambda s: re.fullmatch(r"\w+", s.strip()) is not None,
+            instruction="letras, números o _",
+        )
+
+        if commit_type not in COMMIT_TYPE_INCREMENT:
+            io_warning(
+                f"El tipo '{commit_type}' no produce un salto de versión, "
+                "salvo que se marque como breaking change."
+            )
+
+    # Los commits WIP se squashean en uno final, que es el que puede marcarse como breaking
+    if commit_type != "wip" and io_confirm("¿Es un breaking change?", False):
+        commit_type += "!"
+
     commit_message = io_prompt(
         "Mensaje de commit",
         validator=lambda s: 0 < len(s) and len(s) < 100,
@@ -162,6 +188,55 @@ def get_commit_message(commit_types: list[str] = COMMIT_TYPES) -> str:
     return commit_type + ": " + commit_message
 
 
+# <tipo>[(alcance)][!]: <mensaje>, para no confundir "Merge pull request 'feature: ...'" con un tipo
+COMMIT_SUBJECT_RE = re.compile(r"^(\w+)(?:\([^)]*\))?(!)?:\s*(.*)$")
+
+
+def show_commits(title: str, revision_range: str):
+    """Muestra en una tabla los commits del rango (fecha relativa, tipo y mensaje).
+    Si no hay commits aborta, ya que no hay nada para mergear."""
+    # fecha de autor: la de commit cambia al hacer rebase (por ejemplo, en release)
+    lines = Git("log", revision_range, format="%at%x09%s").lines()
+
+    if not lines:
+        raise GitFlowError("No hay cambios a mergear.")
+
+    table = Table(title=title, title_justify="left", title_style="bold", box=box.SQUARE)
+    table.add_column("Fecha", style="dim", no_wrap=True)
+    table.add_column("Tipo", style="cyan", no_wrap=True)
+    table.add_column("Mensaje")
+
+    now = time.time()
+
+    for line in lines:
+        timestamp, subject = line.split("\t", 1)
+        match = COMMIT_SUBJECT_RE.match(subject)
+        commit_type, breaking, message = match.groups() if match else ("-", None, subject)
+        commit_type += breaking or ""
+        table.add_row(format_time_ago(now - int(timestamp)), commit_type, message)
+
+    console.print(table)
+
+
+def format_time_ago(seconds: float) -> str:
+    units = [
+        (365 * 24 * 3600, "año", "años"),
+        (30 * 24 * 3600, "mes", "meses"),
+        (7 * 24 * 3600, "semana", "semanas"),
+        (24 * 3600, "día", "días"),
+        (3600, "hora", "horas"),
+        (60, "minuto", "minutos"),
+    ]
+
+    for size, singular, plural in units:
+        amount = int(seconds // size)
+
+        if amount >= 1:
+            return f"hace {amount} {singular if amount == 1 else plural}"
+
+    return "hace un momento"
+
+
 def io_error(message: str, title: str | None = None):
     _io_status(message, "✖ Error: ", "red", title)
 

src/git_flow/command/commit.py

@@ -1,10 +1,13 @@
 from datetime import datetime
 
 import typer
+from rich import box
+from rich.table import Table
 
-import git_flow.command.base as base
 from git_flow import TRASH_BRANCH_PREFIX, WIP_BRANCH_PREFIX, GitFlowError
+from git_flow.command import base
 from git_flow.git import Git
+from git_flow.io import console
 
 app = typer.Typer()
 
@@ -13,7 +16,16 @@ app = typer.Typer()
 def commit():
     """Crea un commit siguiendo el formato de Conventional Commits"""
     base.ensure_initialized()
-    branch = base.ensure_right_branch()
+    branch = base.ensure_on_branch()
+
+    # Una rama WIP termina squasheando en su rama original, que tampoco puede ser un entorno
+    target_branch = branch.removeprefix(WIP_BRANCH_PREFIX)
+
+    if target_branch in base.environments:
+        raise GitFlowError(
+            f"No se puede commitear directamente sobre el entorno '{target_branch}'. "
+            "Debe crear una rama de trabajo con el comando `new`."
+        )
 
     if not _has_files_staged():
         base.io_warning("No hay cambios en el indice para commitear.")
@@ -22,6 +34,11 @@ def commit():
         else:
             raise GitFlowError("Debe agregar algún cambio al indice para continuar.")
 
+    _show_index()
+
+    if not base.io_confirm("¿Desea commitear estos cambios?"):
+        raise GitFlowError("Ejecución cancelada.")
+
     message = base.get_commit_message()
     commit_type = message[: message.index(":")]
 
@@ -54,10 +71,46 @@ def _has_files_staged():
     if not status:
         raise GitFlowError("No hay cambios para commitear.")
 
-    files_in_index = []
+    return any(_is_staged(s) for s in status)
 
-    for s in status:
-        if s.worktree != "?" and s.worktree != " ":
-            files_in_index.append(s.file)
 
-    return len(files_in_index) > 0
+def _is_staged(s: Git.Status) -> bool:
+    return s.index != "?" and s.index != " "
+
+
+INDEX_STATES = {
+    "M": "modificado",
+    "T": "cambio de tipo",
+    "A": "agregado",
+    "D": "eliminado",
+    "R": "renombrado",
+    "C": "copiado",
+    "U": "en conflicto",
+}
+
+
+def _show_index():
+    """Muestra en una tabla los archivos del indice (los que entran en el commit), e informa
+    cuántos archivos quedan con cambios fuera del indice."""
+    status = Git.status()
+    staged = [s for s in status if _is_staged(s)]
+    not_staged = [s for s in status if s.worktree != " "]
+
+    table = Table(
+        title="Cambios a commitear",
+        title_justify="left",
+        title_style="bold",
+        box=box.SQUARE,
+    )
+    table.add_column("Estado", style="cyan", no_wrap=True)
+    table.add_column("Archivo")
+
+    for s in staged:
+        table.add_row(INDEX_STATES.get(s.index, s.index), s.file)
+
+    console.print(table)
+
+    if not_staged:
+        base.io_info(
+            f"{len(not_staged)} archivo(s) con cambios fuera del indice no se incluirán en el commit."
+        )

src/git_flow/command/merge.py

@@ -15,7 +15,7 @@ def merge():
     """Realiza el merge de la rama, o crea el PR para hacerlo si tiene un remoto configurado"""
     base.ensure_initialized()
 
-    branch = base.ensure_right_branch()
+    branch = base.ensure_on_branch()
 
     if branch in base.environments:
         if branch == base.environments[-1]:
@@ -71,27 +71,16 @@ def run_local(branch: str, target: str):
 
 
 def show_commits_to_merge(target):
-    commits = Git("log", target + "..", format="%s").lines()
-
-    if not commits:
-        raise GitFlowError("No hay cambios a mergear.")
-
-    print("Cambios a mergear:")
-
-    for commit in commits:
-        print("- " + commit)
+    base.show_commits("Cambios a mergear", target + "..")
 
 
 def check_merge_conflicts(target: str):
-    merge_conflicts = Git("merge", target, ff=False, commit=False).code(
-        print="Realizando merge de prueba para verificar conflictos"
-    )
-
-    Git("merge", abort=True).exec(print="Abortando merge de prueba", check=False)
+    merge_conflicts = Git.get_merge_conflicts(target, print="Verificando conflictos de merge")
 
     if merge_conflicts:
+        files = "\n".join("  - " + file for file in merge_conflicts)
         base.io_error(
-            f"La rama actual tiene conflictos con {target}.\n"
+            f"La rama actual tiene conflictos con {target}:\n{files}\n\n"
             f"Se recomienda mergear {target} a la rama actual, resolver los conflictos localmente,\n"
             "y ejecutar nuevamente este comando",
             title="Conflictos de merge",

src/git_flow/command/new.py

@@ -14,7 +14,7 @@ def new():
     """Crea una nueva rama siguiendo Conventional Branches"""
 
     base.ensure_initialized()
-    branch = base.ensure_right_branch()
+    branch = base.ensure_on_branch()
 
     if branch not in base.environments:
         base.io_warning("La rama actual no corresponde a un entorno configurado.")

src/git_flow/command/release.py

@@ -12,7 +12,7 @@ def release():
     """Realiza el merge de la rama, o crea el PR para hacerlo si tiene un remoto configurado"""
     base.ensure_initialized()
 
-    branch = base.ensure_right_branch()
+    branch = base.ensure_on_branch()
     env, _ = base.get_branch_env_and_type(branch)
 
     if env == base.environments[-1]:
@@ -32,15 +32,7 @@ def release():
     )
 
     fork_point = Git.get_first_fork_point(branch, env)
-    commits = Git("log", fork_point + "..", format="%s").lines()
-
-    if not commits:
-        raise GitFlowError("No hay cambios a mergear.")
-
-    print("Cambios a pasar al proximo entorno:")
-
-    for commit in commits:
-        print("- " + commit)
+    base.show_commits("Cambios a pasar al próximo entorno", fork_point + "..")
 
     if has_remote and Git.get_tracking_branch(next_env):
         Git("switch", next_env).exec(print="Cambiando a la rama objetivo")

src/git_flow/command/tag.py

@@ -14,6 +14,9 @@ from git_flow.git import Git
 
 app = typer.Typer()
 
+# Código de salida cuando no hace falta crear un tag, para que el CI pueda saltear la publicación
+EXIT_NO_TAG_NEEDED = 3
+
 
 @app.command()
 def tag(target: str | None = None, token: str | None = None, update_changelog: bool = False):
@@ -35,7 +38,7 @@ def tag(target: str | None = None, token: str | None = None, update_changelog: b
     merge_commit_tag = Git("tag", "--points-at", merge_commit).firstline()
     if merge_commit_tag:
         base.io_info(f"El último merge ya tiene un tag: {merge_commit_tag}")
-        return
+        raise typer.Exit(code=EXIT_NO_TAG_NEEDED)
 
     token, ci = get_token_and_ci(token)
 
@@ -97,7 +100,7 @@ def tag(target: str | None = None, token: str | None = None, update_changelog: b
             "Los cambios realizados no implican un salto de versión, se mantiene la anterior."
         )
 
-        raise typer.Exit(code=1)
+        raise typer.Exit(code=EXIT_NO_TAG_NEEDED)
 
     if update_changelog:
         changelog = Changelog()
@@ -128,8 +131,14 @@ def get_next_tag_from_commits(
 ) -> str | None:
     increment = SEMVER_SKIP
     for commit in commits:
-        commit_type = commit.partition(":")[0]
-        increment = max(increment, COMMIT_TYPE_INCREMENT.get(commit_type, SEMVER_SKIP))
+        match = base.COMMIT_SUBJECT_RE.match(commit)
+
+        if not match:
+            continue
+
+        commit_type, breaking, _ = match.groups()
+        commit_increment = SEMVER_MAJOR if breaking else COMMIT_TYPE_INCREMENT.get(commit_type)
+        increment = max(increment, commit_increment or SEMVER_SKIP)
 
     if increment == SEMVER_SKIP:
         return None

src/git_flow/git.py

@@ -1,6 +1,10 @@
 import subprocess
 from dataclasses import dataclass
 
+from rich.markup import escape
+from rich.panel import Panel
+from rich.text import Text
+
 from git_flow import FLOWCONFIG_FILENAME
 from git_flow.io import *
 
@@ -22,8 +26,9 @@ class Git:
         file: str
 
         def __init__(self, line: str) -> None:
-            self.worktree = line[0]
-            self.index = line[1]
+            # Formato porcelain "XY <file>": X es el estado en el indice, Y en el worktree
+            self.index = line[0]
+            self.worktree = line[1]
             self.file = line[3:].strip("\n")
 
     command: list[str]
@@ -58,6 +63,21 @@ class Git:
     def get_branches(prefix: str = ""):
         return Git._get_references("heads/" + prefix)
 
+    @staticmethod
+    def get_merge_conflicts(target: str, print: str | None = None) -> list[str]:
+        """Archivos con conflictos al mergear target en HEAD. El merge se resuelve en memoria con
+        merge-tree, sin tocar el índice ni el worktree."""
+        process = Git(
+            "merge-tree", "HEAD", target, write_tree=True, name_only=True, messages=False
+        )._get(print, check=False)
+
+        # 0: sin conflictos, 1: con conflictos, otro: error (por ejemplo, historias sin relación)
+        if process.returncode not in (0, 1):
+            process.check_returncode()
+
+        # Primera línea: OID del árbol resultante, luego los archivos en conflicto
+        return [l for l in process.stdout.splitlines()[1:] if l]
+
     @staticmethod
     def status():
         return list(map(Git.Status, Git("status", porcelain=True).lines(False)))
@@ -166,7 +186,7 @@ class Git:
         process = self._get(**kwargs)
         lines = process.stdout.splitlines()
 
-        return lines if not strip else list(map(lambda l: l.strip(), lines))
+        return lines if not strip else [l.strip() for l in lines]
 
     def firstline(self, **kwargs):
         lines = self.lines(**kwargs)
@@ -180,10 +200,13 @@ class Git:
         self._run(**kwargs)
 
     def _get(self, print: str | None = None, check: bool = True):
-        process = subprocess.run(self.command, capture_output=True, text=True)
+        process = subprocess.run(self.command, capture_output=True, text=True, check=False)
 
-        if print is not None:
-            self._print_process(process.stdout, process.stderr, print)
+        # Sin --verbose solo se muestra el paso; si falla, la salida la muestra main()
+        if print is not None and settings.verbose:
+            self._print_process(process, print)
+        elif print is not None:
+            console.print(Text.assemble(("› ", "cyan"), print))
 
         if check:
             process.check_returncode()
@@ -193,7 +216,7 @@ class Git:
     def _run(self, print: str | None = None, check: bool = True):
         return self._get(print, check)
 
-    def _print_process(self, stdout: str, stderr: str, title: str):
+    def _print_process(self, process: subprocess.CompletedProcess, title: str | None):
         command = []
 
         for arg in self.command:
@@ -205,12 +228,25 @@ class Git:
 
             command.append(arg)
 
-        text = f"[green]$ {' '.join(command)}[/green]"
+        ok = process.returncode == 0
+        # git escribe mensajes informativos en stderr, así que solo se resalta si falló
+        stderr_style = "dim" if ok else "red"
+        text = Text.assemble(("$ ", "dim"), (" ".join(command), "bold yellow"))
 
-        for line in stdout.splitlines():
-            text += "\n" + line
+        for line in process.stdout.splitlines():
+            text.append("\n" + line)
 
-        for line in stderr.splitlines():
-            text += "\n[red]" + line + "[/red]"
+        for line in process.stderr.splitlines():
+            text.append("\n" + line, stderr_style)
 
-        panel(title or "Ejecutando", text)
+        console.print(
+            Panel(
+                text,
+                title=f"[bold]{escape(title or 'Ejecutando')}[/bold]",
+                title_align="left",
+                subtitle=None if ok else f"código de salida {process.returncode}",
+                subtitle_align="right",
+                border_style="bright_black" if ok else "red",
+                expand=False,
+            )
+        )

src/git_flow/io.py

@@ -1,10 +1,19 @@
 from rich.console import Console
-from rich.prompt import Prompt, Confirm
 from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
 
 console = Console(highlight=False)
 
 
+class Settings:
+    """Opciones globales de ejecución, configuradas desde la línea de comandos."""
+
+    verbose: bool = False
+
+
+settings = Settings()
+
+
 def success(msg: str):
     console.print(f":white_check_mark: [green]{msg}[/green]")
 

src/git_flow/main.py

@@ -1,12 +1,15 @@
 #!/usr/bin/env python3
 
-import traceback
-from subprocess import SubprocessError
+from subprocess import CalledProcessError, SubprocessError
+from typing import Annotated
 
 import typer
+from rich.markup import escape
+from rich.traceback import Traceback
 
 from git_flow import GitFlowError
 from git_flow.command import base, branch, commit, init, merge, new, release, tag
+from git_flow.io import console, settings
 
 REPOSITORY_TOKEN_PATH = ".repository-token"
 LOCALE = "es_AR.UTF-8"
@@ -22,15 +25,55 @@ app.add_typer(release.app)
 app.add_typer(branch.app)
 
 
+@app.callback()
+def options(
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose",
+            "-v",
+            help="Muestra la salida de los comandos git y el traceback de los errores",
+        ),
+    ] = False,
+):
+    settings.verbose = verbose
+
+
 def main():
     try:
         app()
         print()
     except GitFlowError as e:
-        lines = [str(e), ""]
-        lines += traceback.format_exception(e)
-        base.io_error("".join(lines), title="Git Flow")
+        _print_error(escape(str(e)), "Git Flow", e)
+    except CalledProcessError as e:
+        _print_error(_format_process_error(e), "Comando", e)
     except SubprocessError as e:
-        base.io_error(str(e), title="Comando")
+        _print_error(escape(str(e)), "Comando", e)
     except KeyboardInterrupt:
         base.io_error("Ejecución abortada")
+
+
+def _format_process_error(e: CalledProcessError) -> str:
+    command = " ".join(e.cmd) if isinstance(e.cmd, list) else str(e.cmd)
+    message = f"[bold]$ {escape(command)}[/bold]\nTerminó con código de salida {e.returncode}"
+
+    for output in (e.stdout, e.stderr):
+        if isinstance(output, str) and output.strip():
+            message += "\n\n" + escape(output.strip())
+
+    return message
+
+
+def _print_error(message: str, title: str, e: BaseException):
+    if settings.verbose:
+        base.io_error(message, title=title)
+        console.print(
+            Traceback.from_exception(
+                type(e), e, e.__traceback__, suppress=[typer]
+            )
+        )
+    else:
+        base.io_error(
+            message + "\n\n[dim]Ejecutar con `git-flow --verbose <comando>` para ver el detalle[/dim]",
+            title=title,
+        )