chore: bump version and update CHANGELOG.md [skip ci]

Merge pull request 'bugfix: change checkout version to v7' (#11 ) from feature/change-flow-settings-in-local-config into main
Reviewed-on: #11
2026-07-29 14:56:49 +00:00 · 2026-07-29 14:56:38 +00:00 · 2026-07-29 11:55:54 -03:00 · 2026-07-29 14:49:33 +00:00 · 2026-07-29 11:49:25 -03:00 · 2026-07-29 14:47:56 +00:00
28 changed files with 2266 additions and 767 deletions
@@ -2,3 +2,5 @@
 	remote = origin
 	branches = main
 	initialized = true
+	version = 2
+	remote-type = gitea
@@ -0,0 +1,37 @@
+name: Publish to PyPI
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  Publish-to-PyPI:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0
+
+      - name: Configure git
+        run: |
+          git config --global user.name "gitea-actions"
+          git config --global user.email "actions@git.jonathanteran.dev"
+          git config --global --add safe.directory "$GITHUB_WORKSPACE"
+
+      - name: "Set up Python"
+        uses: actions/setup-python@v6
+        with:
+          python-version-file: ".python-version"
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v8.3.2
+
+      - name: Bump version
+        run: |
+          uv run git-flow tag --token="${{ secrets.GITEA_TOKEN }}"
+
+      - name: Build and publish
+        run: |
+          uv build
+          uv publish --token="${{ secrets.PYPI_TOKEN }}"
@@ -1,5 +1,14 @@
+# Bitbucket token
 .repository-token

-**/__pycache__/
+# Virtual environment
+venv/
+
+# Build folders and artifacts
+dist/
 build/
+**/__pycache__/
 **/*.egg-info/
+
+# MacOS
+.DS_Store
@@ -0,0 +1 @@
+3.14
@@ -1,3 +1,444 @@
+## v1.18.0 - 2026-07-29
+
+- **bugfix**:  change checkout version to v7 [[jteran](mailto:jteran@renatre.org.ar)] (c58c4ce)
+- **bugfix**:  move git fetch to separate line [[jteran](mailto:jteran@renatre.org.ar)] (64fc890)
+- **bugfix**:  change actions/checkout to v4 and add step to fetch tags [[jteran](mailto:jteran@renatre.org.ar)] (dc79ffa)
+- **bugfix**:  change actions/checkout version [[jteran](mailto:jteran@renatre.org.ar)] (c45f065)
+- **bugfix**:  add fetch-tags: true [[jteran](mailto:jteran@renatre.org.ar)] (adcb531)
+- **bugfix**:  remove checkout parameters [[jteran](mailto:jteran@renatre.org.ar)] (2be9b50)
+- **feature**:  show commit count and list tags on workflow [[jteran](mailto:jteran@renatre.org.ar)] (f05582b)
+
+---
+
+
+## v0.1.0-main - 2026-07-29
+
+- **bugfix**:  change actions/checkout to v4 and add step to fetch tags [[jteran](mailto:jteran@renatre.org.ar)] (dc79ffa)
+- **bugfix**:  change actions/checkout version [[jteran](mailto:jteran@renatre.org.ar)] (c45f065)
+- **bugfix**:  add fetch-tags: true [[jteran](mailto:jteran@renatre.org.ar)] (adcb531)
+- **bugfix**:  remove checkout parameters [[jteran](mailto:jteran@renatre.org.ar)] (2be9b50)
+- **feature**:  show commit count and list tags on workflow [[jteran](mailto:jteran@renatre.org.ar)] (f05582b)
+
+---
+
+
+## v0.1.0-main - 2026-07-29
+
+- **feature**:  show commit count and list tags on workflow [[jteran](mailto:jteran@renatre.org.ar)] (f05582b)
+
+---
+
+
+## v0.0.1-main - 2026-07-18
+
+- **bugfix**:  add fetch tags to checkout step [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (f9fb5a6)
+
+---
+
+
+## v0.1.0-main - 2026-07-18
+
+- **feature**:  print current tag command output [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (0cdc012)
+
+---
+
+
+## v0.1.0-main - 2026-07-18
+
+- **style**:  organize imports [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (a08666c)
+- **style**:  format and organize imports [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (726df21)
+- **refactor**:  use base.io_ methods [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (07d4ff9)
+- **refactor**:  use base.io_ methods [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (919e680)
+- **refactor**:  use base.io_ methods [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (add4cd2)
+- **style**:  run black formatter on merge.py [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (e4833c9)
+- **style**:  run black formatter on commit.py [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (7315681)
+- **style**:  run black formatter on new.py [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (ba1c9bd)
+- **style**:  run black formatter [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (1a7ae33)
+- **refactor**:  use new base.io_ methods [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (0120faa)
+- **refactor**:  use unsafe_ask in favor of global error catch [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (febd18c)
+- **style**:  run black formatter [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (069c33b)
+- **refactor**:  reword current branch check, move if around so it's better placed [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (1d186e1)
+- **feature**:  change unicode status icons [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (c0f7642)
+
+---
+
+
+## v1.17.6 - 2026-07-09
+
+- **bugfix**:  actualizo versiones de checkout, setup-python, clonar depth completo [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (4666503)
+
+---
+
+
+## v0.1.0-main - 2026-07-09
+
+- **bugfix**:  usar https por defecto como esquema si se detecta ssh [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (5989699)
+- **feature**:  usar esquema de remoto para host de api gitea [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (ecfe058)
+- **bugfix**:  agregar setup previo a ejecucion de git tag [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (1cc2de0)
+- **bugfix**:  arreglo acceso a secretos [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (d456565)
+- **bugfix**:  agrego fetch-depth a checkout [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (ad8984c)
+- **bugfix**:  agrego log de git luego del checkout [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (bf6a0e8)
+- **bugfix**:  cambio version de action setup-uv [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (cb74242)
+- **feature**:  agrego workflow para subir paquete a pypi [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (e94ee2c)
+
+---
+
+
+## v0.1.0-main - 2026-07-09
+
+- **bugfix**:  agregar setup previo a ejecucion de git tag [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (1cc2de0)
+- **bugfix**:  arreglo acceso a secretos [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (d456565)
+- **bugfix**:  agrego fetch-depth a checkout [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (ad8984c)
+- **bugfix**:  agrego log de git luego del checkout [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (bf6a0e8)
+- **bugfix**:  cambio version de action setup-uv [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (cb74242)
+- **feature**:  agrego workflow para subir paquete a pypi [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (e94ee2c)
+
+---
+
+
+## v1.17.5 - 2026-06-03
+
+- **bugfix**:  allow commits not compliant with conventional commits in changelog generation [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (3ff9f76)
+
+---
+
+
+## v1.17.4 - 2026-05-24
+
+- **bugfix**:  use rest of branch name instead of ticket for pr title generation [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (094bc1a)
+
+---
+
+
+## v1.17.3 - 2026-05-22
+
+- **bugfix**:  dont close branches on merges between environments [[jteran](mailto:jteran@renatre.org.ar)] (8ee0129)
+
+---
+
+
+## v1.17.2 - 2026-05-22
+
+- **bugfix**:  change pr title on merges between environments [[jteran](mailto:jteran@renatre.org.ar)] (de124ba)
+
+---
+
+
+## v1.17.1 - 2026-05-20
+
+- **bugfix**:  dont push environment branches since they are already created on remote [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (04c9a4b)
+
+---
+
+
+## v1.17.0 - 2026-05-20
+
+- **feature**:  allow merges between environments [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (5806aea)
+
+---
+
+
+## v1.16.1 - 2026-05-20
+
+- **bugfix**:  arreglo split de branch para armar correctamente el titulo del PR [[jteran](mailto:jteran@renatre.org.ar)] (a0d3028)
+
+---
+
+
+## v1.16.0 - 2026-05-20
+
+- **feature**:  agrego soporte para especificar tickets en nombre e rama [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (f389118)
+
+---
+
+
+## v1.15.0 - 2026-05-17
+
+- **feature**:  include revlist count in version tag when skipping bump [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (d275ac0)
+
+---
+
+
+## v1.14.0 - 2026-02-11
+
+- **feature**:  actualizar nombre de proyecto en uv.lock [[jteran](mailto:jteran@renatre.org.ar)] (9cd0b25)
+
+---
+
+
+## v1.13.1 - 2026-02-11
+
+- **bugfix**:  test pipeline change [[jteran](mailto:jteran@renatre.org.ar)] (f2eb5af)
+
+---
+
+
+## v1.13.0 - 2026-02-11
+
+- **feature**:  actualizo nombre y descripcion del proyecto [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (41d6957)
+
+---
+
+
+## v1.12.3 - 2026-02-11
+
+- **bugfix**:  taggeo todos los commits localmente, incluso en ci [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (5d23bb6)
+
+---
+
+
+## v1.12.2 - 2026-02-10
+
+- **bugfix**:  test pipeline change [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (98bf7e7)
+
+---
+
+
+## v1.12.1 - 2026-02-10
+
+- **bugfix**:  agrego paso de build al pipeline [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (ade86f1)
+
+---
+
+
+## v1.12.0 - 2026-02-10
+
+- **feature**:  cambio pipelines para usar uv package manager [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (0f700b0)
+
+---
+
+
+## v1.11.0 - 2025-12-22
+
+- **feature**:  al agrupar release, mergear cambios en rama group [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (726c73a)
+- **feature**:  usar commit message cuando el pr solo tiene un commit [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (057b32a)
+- **feature**:  eliminar prompt de ticket en creacion de rama [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (c0e2e59)
+- **feature**:  deshacer rebase cuando este falla en el pasaje de cambios [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (77e338d)
+- **bugfix**:  uso titulo personalizado de PR [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (1aa2263)
+
+---
+
+
+## v1.10.0 - 2025-12-15
+
+- **feature**:  agrego opcion para cambiar a rama objetivo y obtener cambios [[jteran](mailto:jteran@renatre.org.ar)] (df8998a)
+- **feature**:  agrego opcion para personalizar nombre de PR [[jteran](mailto:jteran@renatre.org.ar)] (c87b141)
+
+---
+
+
+## v1.9.1 - 2025-12-15
+
+- **bugfix**:  uso rama actual cuando esta es un entorno [[jteran](mailto:jteran@renatre.org.ar)] (c54cb95)
+
+---
+
+
+## v1.9.0 - 2025-12-15
+
+- **bugfix**:  uso env actual en vez de rama actual para listar ramas [[jteran](mailto:jteran@renatre.org.ar)] (5d33b29)
+- **feature**:  listar ramas de todos los entornos con flag --all, y del entorno actual por defecto [[jteran](mailto:jteran@renatre.org.ar)] (104b321)
+- **feature**:  agrego opcion para listar ramas wip [[jteran](mailto:jteran@renatre.org.ar)] (774cf9a)
+- **refactor**:  cambio opcion para listar ramas trash [[jteran](mailto:jteran@renatre.org.ar)] (74c333a)
+- **bugfix**:  elimino : extra de comando new [[jteran](mailto:jteran@renatre.org.ar)] (499babc)
+
+---
+
+
+## v1.8.0 - 2025-12-15
+
+- **feature**:  agrego opcion para incluir ticket en nombre de rama [[jteran](mailto:jteran@renatre.org.ar)] (01e938e)
+- **feature**:  mostrar warning si la rama actual no es un entorno configurado [[jteran](mailto:jteran@renatre.org.ar)] (97b4a56)
+- **feature**:  hacer pull en rama actual antes de crear nueva rama [[jteran](mailto:jteran@renatre.org.ar)] (24be501)
+
+---
+
+
+## v1.7.5 - 2025-12-14
+
+- **bugfix**:  verificar si la rama grupo trackea una rama remota antes de hacer pull [[jteran](mailto:jteran@renatre.org.ar)] (0d95a97)
+- **bugfix**:  capturo interrupion por teclado para no mostrar stack trace [[jteran](mailto:jteran@renatre.org.ar)] (0af5102)
+
+---
+
+
+## v1.7.4 - 2025-12-14
+
+- **bugfix**:  generación de PR de ramas release [[jteran](mailto:jteran@renatre.org.ar)] (b24b22a)
+
+---
+
+
+## v1.7.3 - 2025-12-14
+
+- **bugfix**:  listado de ramas para elegir grupo release no devolvia resultados [[jteran](mailto:jteran@renatre.org.ar)] (5600e5e)
+
+---
+
+
+## v1.7.2 - 2025-12-11
+
+- **bugfix**:  al hacer un release, cambio a la rama grupo si esta disponible [[jteran](mailto:jteran@renatre.org.ar)] (44b8efd)
+
+---
+
+
+## v1.7.1 - 2025-12-11
+
+- **bugfix**:  cambio la forma en la que se obtiene el first fork point entre 2 ramas [[jteran](mailto:jteran@renatre.org.ar)] (7b4fb34)
+
+---
+
+
+## v1.7.0 - 2025-12-11
+
+- **feature**:  muestro el listado de commits a pasar al siguiente entorno en release [[jteran](mailto:jteran@renatre.org.ar)] (2e65cb7)
+
+---
+
+
+## v1.6.4 - 2025-12-10
+
+- **bugfix**:  cambio la lista de commits a mostrar en el merge [[jteran](mailto:jteran@renatre.org.ar)] (4e089dc)
+
+---
+
+
+## v1.6.3 - 2025-12-04
+
+- **bugfix**:  revertir guion entre version y entorno, agregar guion a sufijo [[jteran](mailto:jteran@renatre.org.ar)] (7ce6add)
+- **bugfix**:  agrego guion entre version y nombre de entorno [[jteran](mailto:jteran@renatre.org.ar)] (053b8b1)
+
+---
+
+
+## v1.6.3- - 2025-12-04
+
+- **bugfix**:  agrego guion entre version y nombre de entorno [[jteran](mailto:jteran@renatre.org.ar)] (053b8b1)
+
+---
+
+
+## v1.6.2 - 2025-12-04
+
+- **bugfix**:  crear changelog cuando no existe [[jteran](mailto:jteran@renatre.org.ar)] (0c8e7bb)
+
+---
+
+
+## v1.6.1 - 2025-11-29
+
+### Commits
+
+- **bugfix**:  arreglo mensaje de confirmacion de squash, muevo prompt de commit message antes del squash [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (f1f6e67)
+- **bugfix**:  cambio default en confirmacion para agrupar release [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (83df7e9)
+
+---
+
+
+## v1.6.0 - 2025-11-29
+
+### Commits
+
+- **feature**:  agrego opcion para agrupar ramas release [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (c47afff)
+
+---
+
+
+## v1.5.2 - 2025-11-28
+
+### Commits
+
+- **bugfix**:  arreglo split de ramas de flow.branches [[jteran](mailto:jteran@renatre.org.ar)] (2ad7471)
+- **bugfix**:  arreglo iteracion de items de flowconfig en set_config [[jteran](mailto:jteran@renatre.org.ar)] (5c3a317)
+- **docs**:  agrego venv a lista de carpetas ignoradas [[jteran](mailto:jteran@renatre.org.ar)] (50979e2)
+
+---
+
+
+## v1.5.1 - 2025-11-27
+
+### Commits
+
+- **refactor**:  muevo constantes a modulo git_flow para centralizar uso [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (29757cc)
+- **bugfix**:  ignorar carpetas generadas en build de lsp [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (7f857fd)
+
+---
+
+
+## v1.5.0 - 2025-11-27
+
+### Commits
+
+- **feature**:  modifico formato de listado de ramas [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (7177084)
+
+---
+
+
+## v1.4.0 - 2025-11-23
+
+### Commits
+
+- **feature**:  agrego comando branch para listar ramas [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (c74f1a3)
+- **feature**:  agrego soporte para parametros repetidos en llamadas a Git [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (eafb3f1)
+
+---
+
+
+## v1.3.0 - 2025-11-23
+
+### Commits
+
+- **feature**:  agrego comando release, elimino codigo no utilizado [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (43d7e5a)
+
+---
+
+
+## v1.2.0 - 2025-11-22
+
+### Commits
+
+- **bugfix**:  deshabilito check en merge --abort al buscar conflictos [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (34aba71)
+- **feature**:  agregando descripcion a ejecucion de comandos importantes en new, tag y merge [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (4135a78)
+- **feature**:  agregando descripcion a ejecucion de comandos importantes en init y commit [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (faea8c2)
+- **bugfix**:  cambiando tipo de print para agregar soporte de titulos [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (11e2a9d)
+- **bugfix**:  descartar output cuando el comando git se ejecuta con _run [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (d133c48)
+- **feature**:  muevo opciones para check y print a metodos para ejecutar git [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (7346cfd)
+
+---
+
+
+## v1.1.5 - 2025-11-21
+
+### Commits
+
+- **bugfix**:  creo tag en el commit que actualiza el changelog [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (222c819)
+- **style**:  ignorar carpeta dist/ [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (0e75a8e)
+
+---
+
+
+## v1.1.4 - 2025-11-21
+
+### Commits
+
+- **bugfix**:  separar etapa de lectura y escritura de changelog [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (bf829a1)
+- **bugfix**:  agrego http:// como protocolo soportado para pipelines [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (8f79a6a)
+
+---
+
+
+## Saturday,  8 de November de 2025, 00:28
+
+- Autor: [bitbucket-pipelines](mailto:commits-noreply@bitbucket.org)
+- Rama: `14beea150de16e06f7b4e54361584dae5d5ae713`
+
+### Commits
+
+- **bugfix**:  cambio el commit que se usa para generar las entradas del changelog [[jonathan.nerat](mailto:jonathan.nerat@gmail.com)] (14beea1)
+
+---
+
 ## Viernes,  7 de Noviembre de 2025, 11:42

 - Autor: [Jonathan Teran](mailto:jteran@renatre.org.ar)
@@ -1,3 +1,93 @@
 # Git Flow

-Herramienta para establecer un workflow y versionar un repositorio
+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/).
+
+Esta diseñada para facilitar la creación de commits y branches en un formato estandar, que permite
+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:
+
+```sh
+cd ~/Downloads
+git clone git@bitbucket.org:sushi2717/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
+```
+
+## Configuración
+
+Para poder usar la herramienta en un repositorio, necesitamos inicializarlo:
+
+```sh
+git-flow init
+```
+
+El comando solicitará 2 opciones:
+
+- **Ramas principales**: Ramas que representan los entornos principales del proyecto. Por ejemplo:
+  `dev,test,prod`.
+- **Remoto** (opcional): Nombre del remoto que se usará para crear PRs, y taggear merges
+  automáticamente. Por el momento, se soportan los siguientes remotos:
+
+    - [x] Bitbucket
+    - [x] Github
+    - [x] Gitea
+
+  La configuración del remoto requiere tener un Access Token para poder crear los PRs automáticamente.
+  El mismo se puede crear desde el repositorio al que se quiere dar acceso: *"Repository settings" >
+  "Access Tokens" > "Create access token"*. El token necesita permiso para *Write* en *Pull Requests*.
+
+  Luego se debe guardar el token dentro del repositorio a configurar, en el archivo
+  `.repository-token`. De no especificarse, los merges y tags se harán de forma local.
+
+## Utilización
+
+Git Flow cuenta con 5 comandos principales para guiar el workflow (ver `git-flow <command> -h` para
+más información):
+
+- `new`: Crea una nueva rama siguiendo CB.
+- `commit`: Crea un commit siguiendo CC.
+- `merge`: Mergea la rama actual a una de las ramas principales.
+- `tag`: Crea un tag sobre el ultimo merge siguiendo SemVer.
+- `release`: Prepara la rama actual para pasarse al siguiente entorno configurado
+
+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
+   `git-flow new`
+2. Se realizan cambios y se commitean los mismos con `git-flow commit` (se repite hasta que se
+   considere que la rama esté lista para mergear)
+3. Se ejecuta `git-flow merge` para mergear la rama al entorno que corresponda (en este caso,
+   `dev`). En caso de tener un remoto configurado, el comando crea un PR para integrar el cambio. Si
+   no, simplemente se ejecuta un `git merge` simple.
+4. Para versionar este último merge, se ejecuta `git-flow tag`, ya sea localmente o desde un
+   pipeline para que se ejecute en cada merge.
+5. Una vez que la rama fue correctamente integrada a un entorno (por ejemplo, `dev`), se usa
+   `git-flow release` para crear una nueva rama para integrar unicamente los cambios de esa rama
+   sobre el siguiente entorno (por ejemplo, `test`). Si la rama original era
+   `feature/my-new-feature`, se crea la rama `release/test/feature/my-new-feature` sobre `test` que
+   tiene los cambios de la rama original.
+
+## Taggeo automático por pipeline
+
+Éste repositorio utiliza Git Flow para el taggeo automático usando pipelines, se puede ver el
+archivo `bitbucket-pipelines.yml` como ejemplo. El comando `git-flow tag` soporta el pasaje del
+token mediante la opción `--token=<TOKEN>`. Ver la sección [Configuración](#configuracion) para las
+instrucciones de como generar este token. El mismo necesita scope `write:repository:bitbucket`.
@@ -1,14 +1,14 @@
-image: python:3.12
+image: python:3.14

 pipelines:
  branches:
    'main':
      - step:
-          name: "Tag main"
+          name: "Tag and publish package"
          caches:
            - pip
          script:
-            - cd $BITBUCKET_CLONE_DIR
-            - pip install --upgrade pip
-            - pip install .
-            - git-flow tag $BEARER
+            - pip install uv
+            - uv run git-flow tag --token=$BEARER
+            - uv build
+            - uv publish --token=$PYPI_TOKEN
@@ -3,12 +3,12 @@ requires = ["setuptools >= 80", "setuptools-scm[simple] >= 8" ]
 build-backend = "setuptools.build_meta"

 [project]
-name = "git-flow"
-description = "Git workflow automation to follow best practices"
+name = "git-flow-envs"
+description = "Git workflow automation to follow best practices when working with multiple environments"
 dynamic = ["version"]
-requires-python = ">= 3.12"
+requires-python = ">= 3.14"
 dependencies = [
-    "requests"
+    "requests", "typer", "rich", "questionary"
 ]
 authors = [
  {name = "Alan Facundo Biglieri", email = "abiglieri@renatre.org.ar"},
@@ -0,0 +1,6 @@
+{
+  "exclude": [
+    "build",
+    "**/*.egg-info"
+  ]
+}
@@ -0,0 +1,55 @@
+GitFlowError = ValueError
+
+BRANCH_TYPES = [
+    "feature",
+    "refactor",
+    "bugfix",
+    "hotfix",
+    "chore",
+    "docs",
+]
+
+COMMIT_TYPES = [
+    "feature",
+    "bugfix",
+    "hotfix",
+    "refactor",
+    "perf",
+    "docs",
+    "style",
+    "test",
+    "wip",
+]
+
+WIP_BRANCH_PREFIX = "wip/"
+TRASH_BRANCH_PREFIX = "trash/"
+
+# Commits con estos valores incrementan el componente correspondiente
+SEMVER_MAJOR = 3
+SEMVER_MINOR = 2
+SEMVER_PATCH = 1
+
+# Commits con estos tipos no alteran la versión
+SEMVER_SKIP = 0
+
+COMMIT_TYPE_INCREMENT = {
+    "feature": SEMVER_MINOR,
+    "bugfix": SEMVER_PATCH,
+    "hotfix": SEMVER_PATCH,
+    "refactor": SEMVER_SKIP,
+    "perf": SEMVER_SKIP,
+    "docs": SEMVER_SKIP,
+    "style": SEMVER_SKIP,
+    "test": SEMVER_SKIP,
+}
+
+SUPPORTED_REMOTE_APIS = [
+    "bitbucket.org",
+    "github.com",
+]
+
+REPOSITORY_TOKEN_FILENAME = ".repository-token"
+
+FLOWCONFIG_FILENAME = ".flowconfig"
+
+FLOWCONFIG_VERSION = 2
@@ -0,0 +1,63 @@
+from datetime import datetime
+from os.path import isfile
+
+from git_flow.git import Git
+
+
+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 generate_header(self, title):
+        now = datetime.now()
+
+        return f"""## {title} - {now.strftime("%F")}
+
+"""
+
+    def generate_content(self, base: str, branch: str):
+        commits = Git(
+            "log", base + ".." + branch, first_parent=True, format="%h", merges=False
+        ).lines()
+        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("@")]
+            description = message
+
+            if ":" in message:
+                index = message.index(":")
+                commit_type = message[:index]
+                commit_message = message[index + 1 :]
+                description = f"**{commit_type}**: {commit_message}"
+
+            content += f"- {description} [[{username}](mailto:{email})] ({commit})\n"
+
+        return content
+
+    def generate_footer(self):
+        return """
+---
+
+
+"""
+
+    def generate_entry(self, title: str, base: str, branch: str):
+        return (
+            self.generate_header(title)
+            + self.generate_content(base, branch)
+            + self.generate_footer()
+        )
+
+    def _prepend(self, content: str):
+        if isfile(self.FILENAME):
+            with open(self.FILENAME, "r") as f:
+                content += f.read()
+
+        with open(self.FILENAME, "w") as f:
+            f.write(content)
@@ -0,0 +1,221 @@
+from git_flow import (
+    BRANCH_TYPES,
+    REPOSITORY_TOKEN_FILENAME,
+    FLOWCONFIG_FILENAME,
+    FLOWCONFIG_VERSION,
+    COMMIT_TYPES,
+    GitFlowError,
+)
+from git_flow.git import Git
+from git_flow.remote.base import RemoteAPI
+from git_flow.remote.bitbucket import BitbucketRemoteAPI
+from git_flow.remote.github import GithubRemoteAPI
+from git_flow.remote.gitea import GiteaRemoteAPI
+from git_flow.io import *
+from os.path import isfile
+
+from typing import Optional
+import rich
+import rich.panel
+import questionary
+
+flowconfig = Git.get_config(FLOWCONFIG_FILENAME) if isfile(FLOWCONFIG_FILENAME) else {}
+environments = (
+    flowconfig["flow.branches"].split(",") if "flow.branches" in flowconfig else []
+)
+
+
+def ensure_initialized():
+    initialized = flowconfig["flow.initialized"] if flowconfig else None
+
+    if not initialized:
+        raise GitFlowError(
+            "El repositorio no fue inicializado, debe ejecutar el comando `init`."
+        )
+    elif initialized != "true":
+        raise GitFlowError(
+            f"El valor de `flow.initialized` ({initialized}) es inválido."
+        )
+
+    version = int(flowconfig.get("flow.version", "1"))
+
+    if version != FLOWCONFIG_VERSION:
+        raise GitFlowError(
+            f"La versión del flowconfig ({version}) no es compatible con esta versión de git-flow ({FLOWCONFIG_VERSION}). "
+            f"Debe reinicializar el repositorio."
+        )
+
+
+def ensure_right_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?"):
+        return branch
+    else:
+        raise GitFlowError("Ejecución cancelada.")
+
+
+def get_branch_env_and_type(branch: str) -> tuple[str, str]:
+    components = branch.split("/")
+
+    if len(components) == 2:
+        if components[0] not in BRANCH_TYPES:
+            raise GitFlowError(
+                f"Branch inválida, el tipo '{components[0]}' no es válido."
+            )
+
+        return (environments[0], components[0])
+    elif len(components) == 4:
+        valid_environments = environments[1:]
+
+        if (
+            components[0] != "release"
+            or components[1] not in valid_environments
+            or components[2] not in BRANCH_TYPES
+        ):
+            raise GitFlowError(
+                "Branch release inválido, debe tener el siguiente formato: "
+                "release/<env>/<type>/<name>, pero es: " + branch
+            )
+
+        return (components[1], components[2])
+    else:
+        raise GitFlowError("Branch inválido: " + branch)
+
+
+def ensure_repository_token():
+    if not isfile(REPOSITORY_TOKEN_FILENAME):
+        raise GitFlowError(
+            "No existe un token para el repositorio en " + REPOSITORY_TOKEN_FILENAME
+        )
+
+    with open(REPOSITORY_TOKEN_FILENAME) as f:
+        return f.readline().strip()
+
+
+def ensure_clean_worktree(has_remote: bool):
+    status = Git.status()
+
+    if not status:
+        return
+
+    not_empty = any(map(lambda s: s.index != " " or s.worktree != " ", status))
+
+    if not_empty:
+        if not has_remote:
+            io_warning("Existen cambios en tu entorno de trabajo sin commitear.")
+
+            if not io_confirm("¿Desea continuar?", False):
+                raise GitFlowError("Ejecución abortada")
+        else:
+            raise GitFlowError("No se puede continuar con cambios pendientes.")
+
+
+def get_remote_api(token: str) -> RemoteAPI:
+    if "flow.remote" not in flowconfig:
+        raise GitFlowError("El repositorio no tiene configurado un remoto.")
+
+    remote_type = flowconfig.get("flow.remote-type", "").lower()
+    [schema, host, repository] = RemoteAPI.parse(flowconfig["flow.remote"])
+
+    if remote_type == "gitea":
+        remote_schema = "https://" if schema == "ssh://" else schema
+        return GiteaRemoteAPI(remote_schema + host, repository, token)
+    elif remote_type == "bitbucket":
+        return BitbucketRemoteAPI(repository, token)
+    elif remote_type == "github":
+        return GithubRemoteAPI(repository, token)
+    else:
+        raise GitFlowError("El tipo del remoto es inválido")
+
+
+def is_valid_ticket(ticket: str) -> bool:
+    """Check if the specified string is a valid ticket number (ABC-123)"""
+    components = ticket.split("-")
+
+    if len(components) != 2:
+        return False
+
+    ticket_project = components[0]
+    ticket_number = components[1]
+
+    return (
+        ticket_project.isalpha()
+        and ticket_project.isupper()
+        and ticket_number.isnumeric()
+    )
+
+
+def get_commit_message(commit_types: list[str] = COMMIT_TYPES) -> str:
+    commit_type = io_choice("Tipo de commit", commit_types)
+    commit_message = io_prompt(
+        "Mensaje de commit",
+        validator=lambda s: 0 < len(s) and len(s) < 100,
+        instruction="100 caracteres máximo",
+    )
+    return commit_type + ": " + commit_message
+
+
+def io_error(message: str, title: Optional[str] = None):
+    _io_status(message, "✖ Error: ", "red", title)
+
+
+def io_warning(message: str, title: Optional[str] = None):
+    _io_status(message, "⚠ Warning: ", "yellow", title)
+
+
+def io_info(message: str, title: Optional[str] = None):
+    _io_status(message, "ℹ Info: ", "blue", title)
+
+
+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):
+    if title:
+        rich.print(
+            rich.panel.Panel(
+                message,
+                title=prefix + title,
+                style=style,
+                expand=False,
+                title_align="left",
+            )
+        )
+    else:
+        rich.print(f"[{style}]{prefix}{message}[/{style}]")
+
+
+def io_confirm(question: str, default: bool = True) -> bool:
+    return questionary.confirm(question, default=default, auto_enter=False).unsafe_ask()
+
+
+def io_choice(prompt: str, options: list[str]) -> str:
+    return questionary.select(
+        prompt,
+        options,
+        use_search_filter=True,
+        use_jk_keys=False,
+        instruction="Tipear o usar flechas",
+    ).unsafe_ask()
+
+
+def io_prompt(
+    message: str,
+    default: str = "",
+    persistent: bool = False,
+    strip: bool = False,
+    validator=None,
+    instruction: str | None = None,
+) -> str:
+    if persistent and not validator:
+        validator = lambda s: len(s.strip()) > 0
+
+    value = questionary.text(
+        message, default, validate=validator, instruction=instruction
+    ).unsafe_ask()
+
+    return value.strip() if strip else value
@@ -0,0 +1,146 @@
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+import git_flow.command.base as base
+from git_flow import (
+    TRASH_BRANCH_PREFIX,
+    WIP_BRANCH_PREFIX,
+    GitFlowError,
+)
+from git_flow.git import Git
+
+BRANCH_FORMAT = "%(refname:short)"
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command()
+def branch(
+    environment: Annotated[
+        str | None,
+        typer.Argument(
+            help="Entorno de las ramas a listar. Por defecto, es el entorno actual."
+        ),
+    ] = None,
+    trash: Annotated[
+        bool,
+        typer.Option(
+            help=f"Listar ramas en la 'papelera de reciclaje' (ramas que empiezan con '{TRASH_BRANCH_PREFIX}')"
+        ),
+    ] = False,
+    wip: Annotated[
+        bool,
+        typer.Option(
+            help=f"Listar ramas 'en progreso' (ramas que empiezan con '{WIP_BRANCH_PREFIX}')"
+        ),
+    ] = False,
+    all: Annotated[
+        bool, typer.Option(help="Listar ramas de todos los entornos")
+    ] = False,
+):
+    """Lista ramas del repositorio, agrupandolas por entorno objetivo"""
+    base.ensure_initialized()
+
+    current_branch = Git.get_current_branch()
+
+    if current_branch in base.environments:
+        current_environment = current_branch
+    else:
+        current_environment, _ = base.get_branch_env_and_type(current_branch)
+
+    if trash:
+        show_branches(TRASH_BRANCH_PREFIX, current_branch)
+    elif wip:
+        show_branches(WIP_BRANCH_PREFIX, current_branch)
+    elif all:
+        show_envs(base.environments, current_branch)
+        show_all_branches(base.environments, current_branch)
+    elif environment is None:
+        show_envs(base.environments, current_branch)
+        show_env_branches(current_environment, base.environments, current_branch)
+    elif environment in base.environments:
+        show_envs(base.environments, current_branch)
+        show_env_branches(environment, base.environments, current_branch)
+    else:
+        raise GitFlowError(f"'{environment}' no es un entorno válido.")
+
+
+def show_branches(branch_prefix: str, current_branch: str):
+    branches = get_branches(branch_prefix)
+
+    if not branches:
+        print("No hay ramas a mostrar.")
+        return
+
+    for branch in branches:
+        is_current = branch == current_branch
+        prefix = "*" if is_current else " "
+        console.print(prefix + " " + branch, style="green" if is_current else None)
+
+
+def get_branches(branch_prefix: str):
+    return Git(
+        "for-each-ref", "refs/heads/" + branch_prefix, format=BRANCH_FORMAT
+    ).lines()
+
+
+def show_all_branches(environments: list[str], current_branch: str):
+    for environment in environments:
+        show_env_branches(
+            environment, environments, current_branch, len(environments) > 1
+        )
+
+    trash = len(get_branches(TRASH_BRANCH_PREFIX))
+
+    if trash:
+        print()
+        console.print(
+            "[bold]Papelera:[/bold] "
+            + str(trash)
+            + " rama"
+            + ("" if trash == 1 else "s")
+        )
+
+
+def show_envs(environments: list[str], current_branch: str):
+    console.print("Entornos", style="bold")
+    for environment in environments:
+        is_current = environment == current_branch
+        prefix = "*" if is_current else " "
+        console.print(prefix + " " + environment, style="green" if is_current else None)
+    print()
+
+
+def show_env_branches(
+    environment: str,
+    environments: list[str],
+    current_branch: str,
+    show_env: bool = False,
+):
+    is_first_env = environment == environments[0]
+    pattern = (
+        "refs/heads/" if is_first_env else "refs/heads/release/" + environment + "/"
+    )
+    pattern += "*/*"
+    exclude = (
+        ["refs/heads/" + TRASH_BRANCH_PREFIX, "refs/heads/release/"]
+        if is_first_env
+        else []
+    )
+    branches = Git(
+        "for-each-ref", pattern, exclude=exclude, format=BRANCH_FORMAT
+    ).lines()
+
+    console.print(environment if show_env else "Ramas", style="bold")
+
+    if not branches:
+        print("No hay ramas a mostrar.")
+        return
+
+    for branch in branches:
+        is_current = branch == current_branch
+        prefix = "*" if is_current else " "
+        console.print(prefix + " " + branch, style="green" if is_current else None)
@@ -0,0 +1,63 @@
+from datetime import datetime
+
+import typer
+
+import git_flow.command.base as base
+from git_flow import TRASH_BRANCH_PREFIX, WIP_BRANCH_PREFIX, GitFlowError
+from git_flow.git import Git
+
+app = typer.Typer()
+
+
+@app.command()
+def commit():
+    """Crea un commit siguiendo el formato de Conventional Commits"""
+    base.ensure_initialized()
+    branch = base.ensure_right_branch()
+
+    if not _has_files_staged():
+        base.io_warning("No hay cambios en el indice para commitear.")
+        if base.io_confirm("¿Desea agregar la carpeta actual?"):
+            Git("add", ".").exec(print="Agregando cambios")
+        else:
+            raise GitFlowError("Debe agregar algún cambio al indice para continuar.")
+
+    message = base.get_commit_message()
+    commit_type = message[: message.index(":")]
+
+    if branch.startswith(WIP_BRANCH_PREFIX):
+        original_branch = branch.removeprefix(WIP_BRANCH_PREFIX)
+        Git("commit", m=message).exec(print="Creando commit en rama WIP")
+
+        if commit_type != "wip":
+            suffix = datetime.now().strftime("%Y%m%dT%H%M")
+            Git("switch", original_branch).exec(print="Volviendo a rama original")
+            Git("merge", branch, squash=True).exec(
+                print="Squasheando commits WIP en uno solo"
+            )
+            Git("commit", m=message).exec(print="Creando commit final de rama WIP")
+            Git(
+                "branch", branch, TRASH_BRANCH_PREFIX + branch + "/" + suffix, move=True
+            ).exec(print="Backup de rama WIP")
+    else:
+        if commit_type == "wip":
+            Git("switch", WIP_BRANCH_PREFIX + branch, create=True).exec(
+                print="Creando nueva rama WIP"
+            )
+
+        Git("commit", m=message).exec(print="Creando commit")
+
+
+def _has_files_staged():
+    status = Git.status()
+
+    if not status:
+        raise GitFlowError("No hay cambios para commitear.")
+
+    files_in_index = []
+
+    for s in status:
+        if s.worktree != "?" and s.worktree != " ":
+            files_in_index.append(s.file)
+
+    return len(files_in_index) > 0
@@ -0,0 +1,128 @@
+import typer
+
+import git_flow.command.base as base
+from git_flow import FLOWCONFIG_FILENAME, FLOWCONFIG_VERSION, GitFlowError
+from git_flow.git import Git
+
+app = typer.Typer()
+
+
+@app.command()
+def init():
+    """Inicializa el repositorio para utilizar git-flow"""
+
+    _ensure_is_repository()
+    _ensure_not_already_initialized()
+
+    branches = _setup_flow_branches()
+    remote, remote_type = _setup_flow_remote()
+
+    flowconfig = {
+        "flow.version": str(FLOWCONFIG_VERSION),
+        "flow.initialized": "true",
+        "flow.branches": ",".join(branches),
+    }
+
+    if remote and remote_type:
+        flowconfig["flow.remote"] = remote
+        flowconfig["flow.remote-type"] = remote_type
+
+    Git.set_config(flowconfig, FLOWCONFIG_FILENAME)
+    Git("add", FLOWCONFIG_FILENAME).exec()
+    Git("commit", message="feature: initialize git-flow").exec()
+
+    _ensure_all_flow_branches_exist(branches, remote)
+
+
+def _ensure_is_repository():
+    if not Git.is_repository():
+        base.io_warning("El directorio actual no es un repositorio.")
+
+        if not base.io_confirm("¿Desea inicializarlo?"):
+            raise GitFlowError("No se puede continuar sin inicializar el repositorio")
+
+        Git("init").exec()
+
+
+def _ensure_not_already_initialized():
+    if not base.flowconfig:
+        return
+    elif base.flowconfig.get("flow.initialized") == "true":
+        raise GitFlowError("El repositorio ya fue inicializado para usar git-flow")
+    else:
+        raise GitFlowError("Valor de 'flow.initialized' es inválido")
+
+
+def _setup_flow_branches():
+    base.io_info(
+        """Ingrese las ramas que representan los entornos de deploy del proyecto
+en orden creciente de cercanía al entorno productivo, y separados por
+coma. Por ejemplo: "dev, test, prod".""",
+        title="Configuración de entornos",
+    )
+
+    branches = list(
+        map(lambda b: b.strip(), base.io_prompt("Ramas", "main").split(","))
+    )
+
+    if not all(branches):
+        raise GitFlowError("No puede ingresar una rama vacia")
+
+    return branches
+
+
+def _setup_flow_remote():
+    base.io_info(
+        """Configurar un repositorio remoto le permite generar PRs automáticamente para el
+entorno correspondiente. Deberá seleccionar uno de los remotos actuales, o crear
+uno nuevo.""",
+        title="Configuración de remoto",
+    )
+
+    remote = None
+    remote_type = None
+
+    if base.io_confirm("¿Configurar repositorio remoto?"):
+        remotes = Git("remote").lines(print="Listando remotos disponibles")
+
+        if not remotes:
+            base.io_info("No tiene ningún repositorio remoto, se creará uno.")
+
+            url = base.io_prompt(
+                "Ingrese la URL del repositorio (e.g. https://github.com/user/repo.git)",
+                persistent=True,
+            )
+            remote = "origin"
+            Git("remote", "add", remote, url).exec(print="Agregando remoto")
+        elif len(remotes) == 1:
+            remote = remotes[0]
+        else:
+            base.io_info("Tiene más de un remoto, seleccione el que va a utilizar.")
+            remote = base.io_choice("Remoto", remotes)
+
+        remote_type = base.io_choice(
+            "Tipo de remoto:", ["bitbucket", "github", "gitea"]
+        )
+
+    return (remote, remote_type)
+
+
+def _ensure_all_flow_branches_exist(branches: list[str], remote: str | None):
+    existing_branches = Git.get_branches()
+
+    if not all(map(lambda b: b in existing_branches, branches)):
+        base.io_warning("Algunas de las ramas de entornos expecificadas no existen.")
+        base.io_info("Debe indicar sobre que rama se crearán las ramas de entorno.")
+
+        target_branch = base.io_choice("Rama", existing_branches)
+
+        for branch in branches:
+            if branch not in existing_branches:
+                Git("branch", branch, target_branch).exec(
+                    print="Creando rama inexistente"
+                )
+
+                if remote:
+                    Git("push", remote, branch, set_upstream=True).exec(
+                        print="Creando rama en remoto"
+                    )
@@ -0,0 +1,157 @@
+import typer
+
+import git_flow.command.base as base
+from git_flow import GitFlowError
+from git_flow.changelog import Changelog
+from git_flow.git import Git
+
+app = typer.Typer()
+
+
+@app.command()
+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()
+
+    if branch in base.environments:
+        if branch == base.environments[-1]:
+            raise GitFlowError("No se puede hacer un merge del último entorno.")
+
+        base.io_info(
+            """Está por hacer un merge de 2 entornos que puede implicar muchos cambios en el proyecto.""",
+            "Merge de entornos",
+        )
+
+        if not base.io_confirm("¿Desea continuar?"):
+            raise GitFlowError("Ejecución abortada")
+
+        target = base.environments[base.environments.index(branch) + 1]
+    else:
+        target, _ = base.get_branch_env_and_type(branch)
+
+    if "flow.remote" in base.flowconfig:
+        remote = base.flowconfig["flow.remote"]
+        token = base.ensure_repository_token()
+        run_remote(remote, token, branch, target)
+    else:
+        run_local(branch, target)
+
+
+def run_remote(remote: str, token: str, branch: str, target: str):
+    base.ensure_clean_worktree(True)
+
+    Git("switch", target).exec(print="Cambiando a rama destino")
+    Git("pull").exec(print="Obteniendo ultimos cambios del remoto")
+    Git("switch", "-").exec(print="Volviendo a rama a mergear")
+
+    check_merge_conflicts(target)
+    show_commits_to_merge(target)
+
+    if base.io_confirm(f"¿Crear PR de '{branch}' a '{target}'?"):
+        if branch not in base.environments:
+            Git("push", remote, branch, set_upstream=True).exec(
+                print="Subiendo rama al remoto para crear PR"
+            )
+
+        create_pull_request(token, branch, target)
+
+
+def run_local(branch: str, target: str):
+    base.ensure_clean_worktree(False)
+    check_merge_conflicts(target)
+    show_commits_to_merge(target)
+
+    if base.io_confirm(f"¿Mergear rama '{branch}' a '{target}'?"):
+        Git("switch", target).exec(print="Cambiando a rama destino")
+        Git("merge", branch, ff=False).exec(print="Mergeando")
+
+
+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)
+
+
+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)
+
+    if merge_conflicts:
+        base.io_error(
+            f"La rama actual tiene conflictos con {target}.\n"
+            f"Se recomienda mergear {target} a la rama actual, resolver los conflictos localmente,\n"
+            "y ejecutar nuevamente este comando",
+            title="Conflictos de merge",
+        )
+        raise GitFlowError("Ejecución abortada.")
+    else:
+        base.io_success("No se detectaron merge conflicts.")
+
+
+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)
+
+    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)
+
+    message = base.get_remote_api(token).create_pull_request(
+        branch,
+        target,
+        title,
+        changelog.generate_content(target, branch),
+        branch not in base.environments,
+    )
+
+    base.io_success(message, "Rama creada")
+
+    if base.io_confirm("¿Desea cambiar a la rama objetivo y bajar los cambios?"):
+        Git("switch", target).exec(print="Cambiando a rama objetivo")
+        Git("pull").exec(print="Obteniendo cambios")
+
+
+def _get_pr_title_from_branch(branch: 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>
+    branch_type = components[-2]
+    branch_desc = 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 :]
+
+    return " ".join(
+        filter(
+            None,
+            [
+                f"[Pasaje a {components[1]}]" if len(components) == 4 else None,
+                branch_type + ":",
+                branch_ticket,
+                branch_desc.replace("-", " "),
+            ],
+        )
+    )
@@ -0,0 +1,69 @@
+from typing import Optional
+
+import typer
+
+import git_flow.command.base as base
+from git_flow import BRANCH_TYPES
+from git_flow.git import Git
+
+app = typer.Typer()
+
+
+@app.command()
+def new():
+    """Crea una nueva rama siguiendo Conventional Branches"""
+
+    base.ensure_initialized()
+    branch = base.ensure_right_branch()
+
+    if branch not in base.environments:
+        base.io_warning("La rama actual no corresponde a un entorno configurado.")
+
+    base.io_info(
+        "Se creará una nueva rama de trabajo sobre la rama actual.\n"
+        "Debe seleccionar el tipo de cambio a realizar.",
+        title="Tipo de cambio",
+    )
+
+    branch_type = base.io_choice("Tipos de cambio", BRANCH_TYPES)
+    ticket = _get_optional_ticket()
+    new_branch = _get_unique_branch_name(branch_type, ticket)
+
+    if "flow.remote" in base.flowconfig and Git.get_tracking_branch(branch):
+        Git("pull").exec(print="Actualizando rama actual")
+
+    if base.io_confirm(f"¿Crear rama '{new_branch}' sobre la rama actual?"):
+        Git("switch", new_branch, create=True).exec(print="Creando nueva rama")
+
+
+def _get_optional_ticket() -> Optional[str]:
+    return base.io_prompt(
+        "Ticket que respalda el cambio (en formato ABC-123)",
+        validator=lambda x: len(x.strip()) == 0 or base.is_valid_ticket(x),
+    )
+
+
+def _get_unique_branch_name(branch_type: str, ticket: Optional[str]) -> str:
+    base.io_info(
+        f"Ingrese las palabras clave que describan el cambio de tipo '{branch_type}'.\n"
+        "Las mismas se utilizaran para generar el nombre de la rama.",
+        title="Nombre de rama",
+    )
+    branch = None
+    branches = Git.get_branches()
+
+    while branch is None:
+        keywords = base.io_prompt("Palabras clave", persistent=True)
+
+        keywords = filter(lambda k: len(k) > 0, keywords.split(" "))
+        branch = (
+            branch_type + "/" + (ticket + "-" if ticket else "") + "-".join(keywords)
+        )
+
+        if branch in branches:
+            base.io_error(
+                f"La rama '{branch}' ya existe, cambie las palabras claves para generar otra"
+            )
+            branch = None
+
+    return branch
@@ -0,0 +1,88 @@
+from typing import Optional
+
+import typer
+
+import git_flow.command.base as base
+from git_flow import COMMIT_TYPES, GitFlowError
+from git_flow.git import Git
+
+app = typer.Typer()
+
+
+@app.command()
+def release(group: Optional[str] = None):
+    """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()
+    env, _ = base.get_branch_env_and_type(branch)
+
+    if env == base.environments[-1]:
+        raise GitFlowError(
+            "No se puede hacer release de una rama en el ultimo entorno."
+        )
+
+    has_remote = "flow.remote" in base.flowconfig
+
+    base.ensure_clean_worktree(has_remote)
+
+    next_env = base.environments[base.environments.index(env) + 1]
+    next_branch = (
+        branch.replace(f"/{env}/", f"/{next_env}/")
+        if branch.startswith("release/")
+        else f"release/{next_env}/{branch}"
+    )
+
+    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)
+
+    grouping = group is not None
+
+    if not group:
+        if base.io_confirm("¿Desea agrupar este release con otra rama?", False):
+            grouping = True
+            group = base.io_choice(
+                "Grupo release: ", Git.get_branches("release/" + next_env + "/")
+            )
+        else:
+            group = next_env
+
+    if has_remote and Git.get_tracking_branch(group):
+        Git("switch", group).exec(print="Cambiando a la rama objetivo")
+        Git("pull").exec(print="Sincronizando cambios la rama objetivo")
+        Git("switch", "-").exec(print="Volviendo a la rama original")
+
+    if len(commits) > 1 and base.io_confirm(
+        f"¿Desea reemplazar los {len(commits)} commits de la rama por uno solo?", False
+    ):
+        base.io_info("Debe ingresar el mensaje del commit a crear.")
+        message = base.get_commit_message(COMMIT_TYPES[:-1])
+
+        Git("switch", next_branch, fork_point, create=True).exec(
+            print="Creando rama release en base"
+        )
+        Git("merge", branch, squash=True).exec(print="Squasheando commits en uno solo")
+        Git("commit", m=message).exec(print="Creando commit único")
+    else:
+        Git("switch", next_branch, create=True).exec(print="Creando rama release")
+
+    status = Git("rebase", fork_point, next_branch, onto=group).code(
+        print="Moviendo cambios hacia el siguiente ambiente"
+    )
+
+    if status:
+        Git("rebase", abort=True).exec(print="Deshaciendo cambios por conflictos")
+        raise GitFlowError("Error al realizar pasaje de cambios a rama objetivo")
+    elif grouping:
+        Git("switch", group).exec(print="Cambiando a rama objetivo")
+        Git("merge", next_branch, ff_only=True).exec(
+            print="Mergeando cambios de la nueva rama"
+        )
@@ -0,0 +1,111 @@
+from typing import Optional
+
+import typer
+
+import git_flow.command.base as base
+from git_flow import (
+    COMMIT_TYPE_INCREMENT,
+    SEMVER_MAJOR,
+    SEMVER_MINOR,
+    SEMVER_PATCH,
+    SEMVER_SKIP,
+    GitFlowError,
+)
+from git_flow.changelog import Changelog
+from git_flow.git import Git
+
+app = typer.Typer()
+
+
+@app.command()
+def tag(token: Optional[str] = None):
+    """Crea un nuevo tag para el último merge."""
+    base.ensure_initialized()
+
+    target = Git.get_current_branch()
+
+    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:
+        raise GitFlowError("No hay token disponible")
+
+    changelog = Changelog()
+
+    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:
+        return (token, True)
+
+
+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:
+    increment = SEMVER_SKIP
+    for commit in commits:
+        commit_type = commit[: commit.index(":")]
+        increment = max(increment, COMMIT_TYPE_INCREMENT.get(commit_type, SEMVER_SKIP))
+
+    tag = Git.get_current_tag() or f"v0.0.0-{branch}"
+
+    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("."))
+
+    if increment == SEMVER_MAJOR:
+        major += 1
+        minor = 0
+        patch = 0
+    elif increment == SEMVER_MINOR:
+        minor += 1
+        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}"
@@ -1,9 +1,11 @@
 import subprocess

-from .io import *
+from git_flow import FLOWCONFIG_FILENAME
+from git_flow.io import *


-class Status:
+class Git:
+    class Status:
        worktree: str
        index: str
        file: str
@@ -13,56 +15,75 @@ class Status:
            self.index = line[1]
            self.file = line[3:].strip("\n")

-
-class Git:
-    FLOWCONFIG_FILE = ".flowconfig"
-    CHANGELOG_FILE = "CHANGELOG.md"
-    BUMP_VERSION = "chore: bump version and update CHANGELOG.md [skip ci]"
-
    command: list[str]
-    check_returncode: bool = True
+
+    @staticmethod
+    def get_config(file: str | None = None):
+        config: dict[str, str] = {}
+        lines = Git("config", file=file, list=True).lines()
+
+        for line in lines:
+            pos = line.index("=")
+            key = line[:pos]
+            value = line[pos + 1 :]
+            config[key] = value
+
+        return config
+
+    @staticmethod
+    def set_config(config: dict[str, str], file: str | None = None):
+        for key, value in config.items():
+            Git("config", key, value, file=file).exec()

    @staticmethod
    def flow_config(*args, **kwargs):
-        return Git("config", *args, file=Git.FLOWCONFIG_FILE, **kwargs)
+        return Git("config", *args, file=FLOWCONFIG_FILENAME, **kwargs)

    @staticmethod
    def get_current_branch():
        return Git("rev-parse", "HEAD", abbrev_ref=True).firstline()

    @staticmethod
-    def get_branches():
-        return Git._get_references("heads")
+    def get_branches(prefix: str = ""):
+        return Git._get_references("heads/" + prefix)

    @staticmethod
    def status():
-        return list(map(Status, Git("status", porcelain=True).lines(False)))
+        return list(map(Git.Status, Git("status", porcelain=True).lines(False)))

    @staticmethod
    def get_current_tag():
-        return Git("describe", abbrev="0", tags=True).without_checking().firstline()
+        return Git("describe", abbrev="0", tags=True).firstline(check=False, print="Obteniendo tag actual")

    @staticmethod
    def get_first_fork_point(branch: str, env: str):
-        boundary_commits = list(filter(
-            lambda c: c.startswith("-"), # boundary commits
-            Git("rev-list", env + "..." + branch, topo_order=True, boundary=True).lines()
-        ))
+        # Lista de commits alcanzables por el entorno (por ejemplo, dev),
+        env_commits = Git("rev-list", env + "..." + branch, first_parent=True).lines()

-        if not boundary_commits:
+        if not env_commits:
            raise RuntimeError("No se encontro un commit base para realizar el rebase.")

-        return boundary_commits[-1].removeprefix("-")
+        return Git("show", env_commits[-1] + "^", patch=False, format="%h").firstline()

    @staticmethod
    def _get_references(kind: str):
-        prefix = "refs/" + kind + "/"
-        return map(
-            lambda r: r.removeprefix(prefix),
-            Git("for-each-ref", prefix + "*", format="%(refname)").lines(),
-        )
+        prefix = "refs/" + kind
+        return Git("for-each-ref", prefix + "**", format="%(refname:short)").lines()

-    def __init__(self, subcommand: str, *args: str, **kwargs: str | int | bool) -> None:
+    @staticmethod
+    def is_repository() -> bool:
+        return Git("rev-parse", is_inside_work_tree=True).code() == 0
+
+    @staticmethod
+    def get_tracking_branch(branch: str) -> str | None:
+        try:
+            return Git("rev-parse", branch + "@{upstream}", abbrev_ref=True).firstline()
+        except subprocess.CalledProcessError:
+            return None
+
+    def __init__(
+        self, subcommand: str, *args: str, **kwargs: str | int | bool | list[str] | None
+    ) -> None:
        self.command = ["git", subcommand]

        for option, value in kwargs.items():
@@ -74,6 +95,11 @@ class Git:
                else:
                    prefix = "--" if value else "--no-"
                    self.command.append(prefix + option)
+            elif value is None:
+                continue
+            elif isinstance(value, list):
+                for v in value:
+                    self.command.append("--" + option + "=" + v)
            else:
                value = value if isinstance(value, str) else str(value)

@@ -85,44 +111,38 @@ class Git:

        self.command += args

-    def lines(self, strip: bool = True):
-        process = subprocess.run(self.command, capture_output=True, text=True)
-
-        self.__print_process(process.stdout, process.stderr)
-
-        if self.check_returncode:
-            process.check_returncode()
-
+    def lines(self, strip: bool = True, **kwargs):
+        process = self._get(**kwargs)
        lines = process.stdout.splitlines()

        return lines if not strip else list(map(lambda l: l.strip(), lines))

-    def firstline(self):
-        lines = self.lines()
+    def firstline(self, **kwargs):
+        lines = self.lines(**kwargs)

        return lines[0] if lines else ""

-    def exec(self):
+    def code(self, **kwargs):
+        return self._run(check=False, **kwargs).returncode
+
+    def exec(self, **kwargs):
+        self._run(**kwargs)
+
+    def _get(self, print: str | None = None, check: bool = True):
        process = subprocess.run(self.command, capture_output=True, text=True)

-        self.__print_process(process.stdout, process.stderr)
+        if print is not None:
+            self._print_process(process.stdout, process.stderr, print)

-        if self.check_returncode:
+        if check:
            process.check_returncode()

-    def code(self):
-        process = subprocess.run(self.command, capture_output=True, text=True)
+        return process

-        self.__print_process(process.stdout, process.stderr)
+    def _run(self, print: str | None = None, check: bool = True):
+        return self._get(print, check)

-        return process.returncode
-
-    def without_checking(self):
-        self.check_returncode = False
-
-        return self
-
-    def __print_process(self, stdout: str, stderr: str):
+    def _print_process(self, stdout: str, stderr: str, title: str):
        command = []

        for arg in self.command:
@@ -134,10 +154,12 @@ class Git:

            command.append(arg)

-        print(COLOR_YELLOW + "> " + " ".join(command) + COLOR_RESET)
+        text = f"[green]$ {" ".join(command)}[/green]"

        for line in stdout.splitlines():
-            print(COLOR_BLUE + "< " + line + COLOR_RESET)
+            text += "\n" + line

        for line in stderr.splitlines():
-            print(COLOR_RED + "! " + line + COLOR_RESET)
+            text += "\n[red]" + line + "[/red]"
+
+        panel(title or "Ejecutando", text)
@@ -1,64 +1,55 @@
-import sys
+from rich.console import Console
+from rich.prompt import Prompt, Confirm
+from rich.panel import Panel
+
+console = Console(highlight=False)


-COLOR_BLACK = '\033[30m'
-COLOR_RED = '\033[31m'
-COLOR_GREEN = '\033[32m'
-COLOR_YELLOW = '\033[33m'
-COLOR_BLUE = '\033[34m'
-COLOR_BLACK_BOLD = '\033[1;30m'
-COLOR_RESET = '\033[0m'
+def success(msg: str):
+    console.print(f":white_check_mark: [green]{msg}[/green]")


-def confirm(prompt, default: bool = True):
-    user_input = input(prompt + (" [Y/n]: " if default else " [y/N]: "))
-
-    return default if len(user_input) == 0 else user_input.startswith("y")
+def warning(msg: str):
+    console.print(f":warning: [yellow]{msg}[/yellow]")


-def choose(prompt: str, options: list[str]):
-    print(prompt)
+def error(msg: str):
+    console.print(f":x: [red]{msg}[/red]")

-    for i, option in enumerate(options):
-        print(f"\t{i+1}. {option}")

-    selection = None
+def info(msg: str):
+    console.print(f":information: [blue]{msg}[/blue]")

-    while selection is None:
-        user_input = input(f"Seleccione una opción [1-{len(options)}] o escribala: ")

-        if user_input.isdigit():
-            user_input = int(user_input)
+def panel(title: str, text: str):
+    console.print(Panel(text, title=title, expand=False, title_align="left"))

-            if 1 <= user_input and user_input <= len(options):
-                selection = options[user_input - 1]

-                if not confirm(
-                    f"Seleccionó la opción {user_input} ({selection}), ¿es correcto?"
-                ):
-                    selection = None
+def prompt(
+    prompt: str,
+    default: str | None = None,
+    persistent: bool = False,
+    strip: bool = True,
+) -> str:
+    onetime = not persistent
+
+    while onetime or persistent:
+        result = Prompt.ask(prompt)
+        result = result.strip() if strip else result
+
+        if result:
+            return result
+        elif default is not None:
+            return default
+        elif persistent:
+            error("Debe ingresar un valor no vacío.")
        else:
-                print_error(f"La opción {user_input} está fuera del rango permitido.")
-        elif user_input in options:
-            selection = user_input
-        else:
-            print_error(f"La opción '{user_input}' es inválida.")
-
-    return selection
+            return result


-def print_error(message: str):
-    print(f"{COLOR_RED}[err] {message}{COLOR_RESET}", file=sys.stderr)
+def confirm(question: str, default: bool = True):
+    return Confirm.ask(question, default=default)


-def print_warning(message: str):
-    print(f"{COLOR_YELLOW}[wrn] {message}{COLOR_RESET}")
-
-def print_success(message: str):
-    print(f"{COLOR_GREEN}[ok!] {message}{COLOR_RESET}")
-
-def print_info(message: str):
-    print(f"{COLOR_BLUE}[inf] {message}{COLOR_RESET}")
-
-def print_debug(message: str):
-    print(f"{COLOR_BLACK_BOLD}[dbg] {message}{COLOR_RESET}")
+def choice(prompt: str, options: list[str]):
+    return Prompt.ask(prompt, choices=options)
@@ -1,658 +1,32 @@
 #!/usr/bin/env python3

-import os
-import sys
-import datetime
-import requests
-import locale
+import typer

-from .git import Git
-from .io import *
+from git_flow import GitFlowError
+import git_flow.command.base as base
+from git_flow.command import init, new, commit, merge, tag, release, branch
+
+REPOSITORY_TOKEN_PATH = ".repository-token"
+LOCALE = "es_AR.UTF-8"


-REPOSITORY_TOKEN_PATH=".repository-token"
-LOCALE = 'es_AR.UTF-8'
+app = typer.Typer()
+app.add_typer(init.app)
+app.add_typer(new.app)
+app.add_typer(commit.app)
+app.add_typer(merge.app)
+app.add_typer(tag.app)
+app.add_typer(release.app)
+app.add_typer(branch.app)


 def main():
    try:
-        locale.setlocale(locale.LC_ALL, LOCALE)
-    except locale.Error as e:
-        print_warning(f"No se pudo configurar el locale '{LOCALE}': {e}")
-
-    args = sys.argv
-
-    if len(args) < 2:
-        print_error("missing command")
-        return
-
-    command = args[1]
-
-    try:
-        if command == "new":
-            new_command()
-        elif command == "init":
-            init_command()
-        elif command == "commit":
-            commit_command()
-        elif command == "merge":
-            merge_command()
-        elif command == "tag":
-            tag_command()
-        elif command == "release":
-            release_command()
-        elif command == "help":
-            help_command()
-        else:
-            help_command(command)
+        app()
+        print()
+    except GitFlowError as e:
+        base.io_error(str(e), title="Git Flow")
    except Exception as e:
-        print_error(f"Ocurrio un error al ejecutar el comando: {e}")
-
-
-
-BRANCH_TYPES = [
-    "feature",
-    "refactor",
-    "bugfix",
-    "hotfix",
-    "perf",
-    "docs",
-    "typo",
-    "testing",
-    "breaking",
-]
-
-BRANCH_TYPES_INCREMENT = {
-    "feature": "minor",
-    "refactor": "minor",
-    "bugfix": "patch",
-    "hotfix": "patch",
-    "perf": "minor",
-    "docs": "patch",
-    "typo": "patch",
-    "testing": "patch",
-    "breaking": "major",
-}
-
-COMMIT_TYPES = [
-    "feature",
-    "bugfix",
-    "hotfix",
-    "refactor",
-    "perf",
-    "docs",
-    "typo",
-    "testing",
-    "ignore",
-    "wip"
-]
-
-DEFAULT_REMOTE = "origin"
-
-def new_command():
-    current_branch = ensure_right_branch()
-    print_info("Se creará una nueva rama de trabajo sobre la rama actual.")
-    print_info("Seleccione el tipo de cambio a realizar.")
-
-    branch_type = choose("Tipos de cambio", BRANCH_TYPES)
-    branch = get_unique_branch_name(branch_type)
-
-    if confirm(f"Crear rama '{branch}' sobre rama '{current_branch}'"):
-        Git("switch", branch, create=True).exec()
-    else:
-        raise RuntimeError("Abortando operación")
-
-
-def init_command():
-    if not Git("rev-parse", is_inside_work_tree=True).code() == 0:
-        print_warning("El directorio actual no es un repositorio.")
-
-        if not confirm("¿Desea inicializarlo?"):
-            raise RuntimeError("Abortando operación")
-
-        Git("init").exec()
-
-    initialized = Git.flow_config("flow.initialized").without_checking().firstline()
-
-    if initialized == "true":
-        print_error("El repositorio ya fue inicializado")
-        return
-    elif initialized != "": 
-        print_error("El valor de 'flow.initialized' ({initialized}) es inválido")
-        return
-
-    print_info("Ingrese las ramas principales del repositorio separadas por espacio.")
-
-    branches = input("Ramas [dev main]: ").strip()
-    branches = branches.split(" ") if len(branches) > 0 else ["dev", "main"]
-    base = None
-
-    if confirm("¿Desea configurar un repositorio remoto?"):
-        remote = DEFAULT_REMOTE
-        remotes = Git("remote").lines()
-
-        if len(remotes) == 0:
-            print("El repositorio no tiene ningún remoto.")
-
-            url = None
-
-            while url is None:
-                url = input("Ingrese la URL del repositorio (https://github.com/user/repo.git): ").strip()
-
-                if len(url) == 0:
-                    print_error("Debe ingresar una URL")
-                    url = None
-        elif len(remotes) == 1:
-            remote = remotes[0]
-        else:
-            print("Tiene más de un remoto, seleccione el que desea utilizar.")
-            remote = choose("Remotos: ", remotes)
-
-        Git.flow_config("flow.remote", remote).exec()
-
-    Git.flow_config("flow.branches",  " ".join(branches)).exec()
-    Git.flow_config("flow.initialized", "true").exec()
-    Git("add", Git.FLOWCONFIG_FILE).exec()
-    Git("commit", m="feature: initialize git-flow").exec()
-
-    existing_branches = Git.get_branches()
-
-    while base is None:
-        default = Git("rev-parse", "HEAD", abbrev_ref=True).firstline()
-        base = input(f"Ingrese la rama sobre la que desea crear las ramas principales [{default}]: ")
-
-        if not base:
-            base = default
-        elif base not in existing_branches:
-            print_error("Debe ingresar una rama existente.")
-            base = None
-
-    if confirm(f"¿Crear las ramas ingresadas sobre '{base}'?"):
-        for branch in branches:
-            if branch in existing_branches:
-                continue
-
-            if base == "HEAD":
-                Git("branch", branch).exec()
-            else:
-                Git("branch", branch, base).exec()
-
-
-def commit_command():
-    ensure_initialized()
-    branch = ensure_right_branch()
-    status = Git.status()
-
-    if not status:
-        print_error("No hay cambios para commitear.")
-        return
-
-    files_in_index = []
-
-    for s in status:
-        if s.worktree != "?" and s.worktree != " ":
-            files_in_index.append(s.file)
-
-    if not files_in_index:
-        print_warning("No hay cambios en el indice para commitear.")
-        if confirm("¿Desea agregar la carpeta actual (`git add .`)?"):
-            Git("add", ".").exec()
-        else:
-            print_error("Debe agregar algún cambio al indice para continuar.")
-            return
-
-    commit_type = choose("Tipo de commit", COMMIT_TYPES)
-    message = commit_type + ": " + get_commit_message()
-
-    if branch.startswith("wip/"):
-        original_branch = branch.removeprefix("wip/")
-        Git("commit", m=message).exec()
-
-        if commit_type != "wip":
-            now = datetime.datetime.now()
-            suffix = now.strftime("%Y-%m-%d_%H.%M.%S")
-            Git("switch", original_branch).exec()
-            Git("merge", branch, squash=True).exec()
-            Git("commit", m=message).exec()
-            Git("branch", branch, branch + "/" + suffix, move=True).exec()
-    else:
-        if commit_type == "wip":
-            Git("switch", "wip/" + branch, create=True).exec()
-
-        Git("commit", m=message).exec()
-
-
-def merge_command():
-    ensure_initialized()
-    branch = ensure_right_branch()
-
-    if branch.startswith("wip/"):
-        print_error("No se pueden mergear ramas de tipo 'wip'")
-        return
-
-    (target, _) = get_branch_env_and_type(branch)
-    status = Git.status()
-    remote = Git.flow_config("flow.remote").firstline()
-
-    if status:
-        not_empty = any(map(lambda s: s.index != " " or s.worktree != " ", status))
-
-        if not_empty:
-            print_warning("Existen cambios en tu entorno de trabajo sin commitear.")
-
-            if not confirm("¿Desea continuar?", False):
-                return
-
-    if remote:
-        Git("switch", target).exec()
-        Git("pull").exec()
-        Git("switch", "-").exec()
-
-    commits = Git("log", target + "..", format="%s").lines()
-
-    if not commits:
-        print_error("No hay cambios a mergear.")
-        return
-
-    print("Cambios a mergear:")
-
-    for commit in commits:
-        if commit != Git.BUMP_VERSION:
-            print("- " + commit)
-
-    merge_conflicts = Git("merge", target, ff=False, commit=False).exec()
-
-    if merge_conflicts:
-        Git("merge", abort=True).exec()
-        print_error(f"La rama actual tiene conflictos con '{target}'. "
-                     "Se recomienda mergear la rama a la actual, resolver los conflictos, "
-                     "y ejecutar nuevamente este comando.")
-        return
-
-    if remote:
-        Git("push", remote, branch, set_upstream=True).exec()
-        url = Git("remote", "get-url", remote).firstline()
-
-        if url is not None:
-            [service, repository] = parse_url(url)
-            create_pull_request(service, repository, branch, target)
-    else:
-        if confirm(f"Mergear rama '{target}' <= '{branch}'?"):
-            Git("switch", target).exec()
-            Git("merge", branch, ff=False).exec()
-
-
-def parse_url(url: str) -> list[str]:
-    if "@" in url:
-        # git@github.com:username/repository.git
-        start = url.find("@") + 1
-        end = url.find(":")
-        service = url[start : end]
-        start = end + 1
-        end = url.find(".git") if ".git" in url else len(url)
-        repository = url[start : end]
-    elif "://" in url:
-        # https://github.com/username/repository.git
-        start = url.index("://") + 3
-        end = url.index("/", start)
-        service = url[start : end]
-        start = end + 1
-        end = url.find(".git") if ".git" in url else len(url)
-        repository = url[start : end]
-    else:
-        raise RuntimeError("Invalid url: " + url)
-
-    # Esto permite utilizar un Host ficticio si tenemos 2 cuentas de bitbucket (personal y trabajo)
-    if service.endswith(".bitbucket.org"):
-        service = "bitbucket.org"
-
-    return [service, repository]
-
-
-def get_branch_env_and_type(branch: str) -> tuple[str, str]:
-    components = branch.split("/")
-    target_branches = Git.flow_config("flow.branches").firstline().split(" ")
-
-    if len(components) == 2:
-        if components[0] not in BRANCH_TYPES:
-            raise ValueError(f"Branch inválida, el tipo '{components[0]}' no es válido.")
-
-        return (target_branches[0], components[0])
-    elif len(components) == 4:
-        target_branches = target_branches[1:]
-
-        if (
-            components[0] != "release"
-            or components[1] not in target_branches
-            or components[2] not in BRANCH_TYPES
-        ):
-            raise ValueError(
-                "Branch release inválido, debe tener el siguiente formato: "
-                "release/<env>/<type>/<name>, pero es: " + branch
-            )
-
-        return (components[1], components[2])
-    else:
-        raise ValueError("Branch inválido: " + branch)
-
-
-def tag_command():
-    ensure_initialized()
-    ci = len(sys.argv) == 3 # ./git-flow tag <BEARER>
-    token = sys.argv[2] if ci else None
-
-    if token is None:
-        with open(REPOSITORY_TOKEN_PATH, "r") as file:
-            token = file.readline().strip()
-
-    output = Git("log", first_parent=True, merges=True, max_count=1, format="%H,%s").lines()
-
-    if not output:
-        print_error("No hay merges a taggear")
-        return
-
-    output = output[0]
-    pos = output.index(',')
-    commit = output[:pos]
-    message = output[pos+1:]
-    merged_branch = None
-
-    output = Git("describe", commit, tags=True, exact_match=True).without_checking().firstline()
-
-    if output:
-        print_error("El ultimo merge ya tiene tag: " + output)
-        return
-
-    if message.startswith("Merged in "):
-        merged_branch = message.removeprefix("Merged in ")
-        merged_branch = merged_branch[:merged_branch.index(' ')]
-    elif message.startswith("Merge branch '"):
-        merged_branch = message.removeprefix("Merge branch '")
-        merged_branch = merged_branch[:merged_branch.index("'")]
-    else:
-        print_error("No se pudo obtener el nombre de la rama mergeada")
-        return
-
-    remote = Git.flow_config("flow.remote").firstline()
-    branch = Git.get_current_branch()
-    last_version = Git.get_current_tag() or "v1.0.0"
-    from_major = 1
-    until_dash = last_version.index("-") if "-" in last_version else None
-    [major, minor, patch] = map(int, last_version[from_major:until_dash].split("."))
-
-    (_, merged_branch_type) = get_branch_env_and_type(merged_branch)
-    increment = BRANCH_TYPES_INCREMENT[merged_branch_type]
-
-    if increment == "major":
-        major = major + 1
-        minor = 0
-        patch = 0
-    elif increment == "minor":
-        minor = minor + 1
-        patch = 0
-    elif increment == "patch":
-        patch = patch + 1
-
-    last_branch = Git.flow_config("flow.branches").firstline().split(" ")[-1]
-    suffix = "-" + branch if branch != last_branch else ""
-    new_version = f"v{major}.{minor}.{patch}" + suffix
-
-    if ci:
-        url = Git("remote", "get-url", remote).firstline()
-
-        if url:
-            [service, repository] = parse_url(url)
-            create_tag(service, repository, token, new_version, commit)
-
-        if update_changelog(merged_branch, branch):
-            Git("add", Git.CHANGELOG_FILE).exec()
-            Git("commit", message=Git.BUMP_VERSION).exec()
-            Git("push").exec()
-    else:
-        Git("tag", new_version, commit).exec()
-
-
-def release_command():
-    ensure_initialized()
-
-    branch = ensure_right_branch()
-    env_branches = Git.flow_config("flow.branches").firstline().split(" ")
-    (env, _) = get_branch_env_and_type(branch)
-
-    if env == env_branches[-1]:
-        raise RuntimeError("No se puede hacer release de una rama en el ultimo entorno.")
-
-    base = Git.get_first_fork_point(branch, env)
-    next_env = env_branches[env_branches.index(env) + 1]
-    next_branch = branch.replace(f"/{env}/", f"/{next_env}/") if branch.startswith("release/") else f"release/{next_env}/{branch}"
-
-    Git("switch", next_branch, create=True).exec()
-    commits = int(Git("rev-list", base + ".." + next_branch, count=True).firstline())
-
-    if commits > 1 and confirm(f"Desea reemplazar los {commits} commits de la rama por uno solo?"):
-        Git("reset", base, soft=True).exec()
-        commit_type = choose("Tipo de commit", COMMIT_TYPES[:-1]) # Solo permitir commits NO wip
-        Git("commit", m=commit_type + ": " + get_commit_message()).exec()
-
-    Git("rebase", base, next_branch, onto=next_env).exec()
-
-
-def help_command(name: str|None = None):
-    if name is not None:
-        print_error(f"Comando inválido: {name}")
-
-    script = sys.argv[0]
-
-    print(f"""USO:
-    {script} <COMANDO>
-
-COMANDOS:
-    init     inicializa el repositorio por única vez para utilizar git-flow
-    new      crea una nueva rama para realizar cambios
-    commit   crea un commit siguiendo el formato de Conventional Commit
-    merge    actualiza el changelog y crea un nuevo PR para mergear la rama
-    tag      crea un nuevo tag para el ultimo merge
-    release  crea una nueva rama release para pasar la rama actual al siguiente entorno
-    help     muestra este texto de ayuda""", file=sys.stderr)
-
-
-def ensure_initialized():
-    initialized = Git.flow_config("flow.initialized").firstline()
-
-    if initialized == "":
-        raise RuntimeError("El repositorio no fue inicializado, antes de continuar ejecute `git flow init`.")
-    elif initialized != "true":
-        raise RuntimeError(f"El valor de `flow.initialized` ({initialized}) es inválido.")
-
-
-def get_commit_message():
-    message = None
-
-    while message is None:
-        message = input("Mensaje (recomendado: 100 caracteres): ").strip()
-
-        if not message:
-            print_error("El mensaje no puede ser vacío.")
-            message = None
-
-    return message
-
-
-def ensure_right_branch():
-    branch = Git.get_current_branch()
-
-    if branch != "HEAD":
-        if confirm(f"Se encuentra sobre la rama '{branch}'. ¿Es correcto?"):
-            return branch
-
-    raise RuntimeError("Abortando operación")
-
-
-def get_base_branch(branch: str):
-    if branch.startswith("release/"):
-        start = len("release/")
-        end = branch.index("/", start)
-        return branch[start:end]
-    else:
-        return Git.flow_config("flow.branches").firstline().split(" ")[0]
-
-
-def get_unique_branch_name(branch_type):
-    print_info(f"Ingrese las palabras clave que describan el cambio de tipo '{branch_type}'.")
-    branch = None
-    branches = Git.get_branches()
-
-    while branch is None:
-        keywords = input("Palabras clave (por ej. 'edit worker form'): ")
-
-        if len(keywords) == 0:
-            print_error("Debe ingresar al menos una palabra clave.")
-        else:
-            keywords = list(filter(lambda k: len(k) > 0, keywords.split(" ")))
-            branch = branch_type + "/" + "-".join(keywords)
-
-            if branch in branches:
-                print_error(
-                    f"La rama '{branch}' ya existe, cambie las palabras claves para generar otra"
-                )
-                branch = None
-
-    return branch
-
-
-def update_changelog(branch: str, target: str):
-    last_commit = Git("show", "HEAD", no_patch=True, format="%s").firstline()
-
-    if last_commit == Git.BUMP_VERSION:
-        return False
-    else:
-        content = generate_changelog_entry(branch, target)
-
-        if os.path.isfile(Git.CHANGELOG_FILE):
-            with open(Git.CHANGELOG_FILE, "r") as changelog:
-                content = content + changelog.read()
-
-        with open(Git.CHANGELOG_FILE, "w") as changelog:
-            changelog.write(content)
-
-
-        return True
-
-
-def get_changelog_header_lines(branch: str):
-    name = Git("config", "user.name").firstline()
-    email = Git("config", "user.email").firstline()
-
-    now = datetime.datetime.now()
-    weekday = now.strftime("%A").capitalize()
-    month = now.strftime("%B").capitalize()
-    timestamp = now.strftime(f"{weekday}, %e de {month} de %Y, %H:%M")
-
-    return [
-        f"## {timestamp}",
-        "",
-        f"- Autor: [{name}](mailto:{email})",
-        f"- Rama: `{branch}`",
-        "",
-        "### Commits",
-        ""
-    ]
-
-def get_changelog_content_lines(branch: str, target: str):
-    lines = []
-    base = Git.get_first_fork_point(branch, target)
-    commits = Git("log", base + ".." + branch, first_parent=True, format="%h", merges=False).lines()
-
-    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('@')]
-
-        if message == Git.BUMP_VERSION:
-            continue
-
-        index = message.index(":")
-        commit_type = message[:index]
-        commit_message = message[index+1:]
-
-        lines.append(f"- **{commit_type}**: {commit_message} [[{username}](mailto:{email})] ({commit})")
-
-    return lines
-
-def get_changelog_footer_lines():
-    return [
-        "",
-        "---",
-        "",
-        ""
-    ]
-
-def generate_changelog_entry(branch: str, target: str):
-    entry_lines = get_changelog_header_lines(branch)
-    entry_lines += get_changelog_content_lines(branch, target)
-    entry_lines += get_changelog_footer_lines()
-
-    return "\n".join(entry_lines)
-
-
-def create_pull_request(service: str, repository: str, source: str, destination: str):
-    endpoint = get_api_endpoint(service, repository, "/pullrequests")
-    title = source.replace("/", ": ").replace("-", " ")
-    description = "\n".join(get_changelog_content_lines(source, destination))
-    headers = get_headers()
-
-    json = {
-        "title": title,
-        "description": description,
-        "source": {"branch": {"name": source}},
-        "destination": {"branch": {"name": destination}},
-        "close_source_branch": True
-    }
-
-    request = requests.post(endpoint, headers=headers, json=json)
-
-    if request.ok:
-        json = request.json()
-        print_success("PR creado exitosamente: " + json['links']['html']['href'])
-    else:
-        print_error("Ocurrió un error al crear el PR: " + request.text)
-
-
-def create_tag(service: str, repository: str, token: str, tag: str, commit: str):
-    endpoint = get_api_endpoint(service, repository, "/refs/tags")
-    headers = get_headers(token)
-    json = {
-        "name": tag,
-        "target": {
-            "hash": commit
-        }
-    }
-
-    response = requests.post(endpoint, headers=headers, json=json)
-
-    if response.ok:
-        print("Tag creado exitosamente.")
-    else:
-        print_error("Ocurrió un error al crear el tag: " + response.text)
-
-
-def get_headers(token: str | None = None):
-    if not token:
-        with open(REPOSITORY_TOKEN_PATH) as file:
-            token = file.readline().strip()
-
-    return {
-        "Accept": "application/json",
-        "Content-Type": "application/json",
-        "Authorization": "Bearer " + token,
-    }
-
-
-def get_api_endpoint(service: str, repository: str, path: str):
-    if service == "bitbucket.org":
-        return "https://api.bitbucket.org/2.0/repositories/" + repository + path
-
-    return ""
-
-if __name__ == "__main__":
-    main()
+        base.io_error(str(e), title="Inesperado")
+    except KeyboardInterrupt as e:
+        base.io_error("Ejecución abortada")
@@ -0,0 +1,58 @@
+from abc import ABC, abstractmethod
+
+from git_flow import SUPPORTED_REMOTE_APIS, GitFlowError
+from git_flow.git import Git
+
+
+class RemoteAPI(ABC):
+    def __init__(self, repository: str, token: str) -> None:
+        self.repository = repository
+        self.token = token
+
+    @staticmethod
+    def parse(remote: str):
+        url = Git("remote", "get-url", remote).firstline()
+
+        if url.startswith("git@"):
+            at_pos = url.index("@")
+            colon_pos = url.index(":")
+            schema = "ssh://"
+            host = url[at_pos+1:colon_pos]
+            repository = url[colon_pos+1:]
+        elif url.startswith("http://") or url.startswith("https://"):
+            start_pos = url.index("://") + 3
+            uri_start = url.index("/", start_pos)
+            schema = url[:start_pos]
+            host = url[start_pos:uri_start]
+            repository = url[uri_start+1:]
+        else:
+            raise GitFlowError(f"La URL del remoto {remote} es inválida: {url}")
+
+        repository = repository.removesuffix(".git")
+        return [schema, host, repository]
+
+    @abstractmethod
+    def create_pull_request(
+        self,
+        source: str,
+        destination: str,
+        title: str | None = None,
+        description: str | None = None,
+        close_source_branch: bool = True
+    ) -> str:
+        pass
+
+    @abstractmethod
+    def create_tag(self, tag: str, commit: str) -> str:
+        pass
+
+    @abstractmethod
+    def get_endpoint(self, resource: str) -> str:
+        pass
+
+    def get_headers(self):
+        return {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "Authorization": "Bearer " + self.token,
+        }
@@ -0,0 +1,48 @@
+import requests
+from git_flow import GitFlowError
+from git_flow.remote.base import RemoteAPI
+
+
+class BitbucketRemoteAPI(RemoteAPI):
+    API_ENDPOINT = "https://api.bitbucket.org/2.0/repositories"
+
+    def create_pull_request(
+        self,
+        source: str,
+        destination: str,
+        title: str | None = None,
+        description: str | None = None,
+        close_source_branch: bool = True
+    ):
+        request = requests.post(
+            self.get_endpoint("/pullrequests"),
+            headers=self.get_headers(),
+            json={
+                "title": title,
+                "description": description,
+                "source": {"branch": {"name": source}},
+                "destination": {"branch": {"name": destination}},
+                "close_source_branch": close_source_branch,
+            },
+        )
+
+        if request.ok:
+            json = request.json()
+            return "PR creado exitosamente: " + json["links"]["html"]["href"]
+        else:
+            raise GitFlowError("Ocurrió un error al crear el PR: " + request.text)
+
+    def create_tag(self, tag: str, commit: str):
+        response = requests.post(
+            self.get_endpoint("/refs/tags"),
+            headers=self.get_headers(),
+            json={"name": tag, "target": {"hash": commit}},
+        )
+
+        if response.ok:
+            return "Tag creado exitosamente: " + tag
+        else:
+            raise GitFlowError("Ocurrió un error al crear el tag: " + response.text)
+
+    def get_endpoint(self, resource: str) -> str:
+        return f"{BitbucketRemoteAPI.API_ENDPOINT}/{self.repository}/{resource}"
@@ -0,0 +1,55 @@
+import requests
+from git_flow import GitFlowError
+from git_flow.remote.base import RemoteAPI
+
+
+class GiteaRemoteAPI(RemoteAPI):
+    def __init__(self, base_url: str, repository: str, token: str) -> None:
+        super().__init__(repository, token)
+        self.base_url = base_url
+
+    def create_pull_request(
+        self,
+        source: str,
+        destination: str,
+        title: str | None = None,
+        description: str | None = None,
+        close_source_branch: bool = True
+    ) -> str:
+        response = requests.post(
+            self.get_endpoint("/pulls"),
+            headers=self.get_headers(),
+            json={
+                "title": title,
+                "body": description,
+                "head": source,
+                "base": destination,
+            },
+        )
+
+        if response.ok:
+            return "PR creado exitosamente: " + response.json()["html_url"]
+        else:
+            raise GitFlowError("Ocurrió un error al crear el PR: " + response.text)
+
+    def create_tag(self, tag: str, commit: str) -> str:
+        response = requests.post(
+            self.get_endpoint("/tags"),
+            headers=self.get_headers(),
+            json={"tag_name": tag, "target": commit},
+        )
+
+        if response.ok:
+            return "Tag creado exitosamente: " + tag
+        else:
+            raise GitFlowError("Ocurrió un error al crear el tag: " + response.text)
+
+    def get_endpoint(self, resource: str) -> str:
+        return f"{self.base_url}/api/v1/repos/{self.repository}{resource}"
+    
+    def get_headers(self):
+        return {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "Authorization": "token " + self.token,
+        }
@@ -0,0 +1,46 @@
+import requests
+from git_flow import GitFlowError
+from git_flow.remote.base import RemoteAPI
+
+
+class GithubRemoteAPI(RemoteAPI):
+    API_ENDPOINT = "https://api.github.com/repos"
+
+    def create_pull_request(
+        self,
+        source: str,
+        destination: str,
+        title: str | None = None,
+        description: str | None = None,
+        close_source_branch: bool = True
+    ) -> str:
+        response = requests.post(
+            self.get_endpoint("/pulls"),
+            headers=self.get_headers(),
+            json={
+                "title": title,
+                "body": description,
+                "head": source,
+                "base": destination,
+            },
+        )
+
+        if response.ok:
+            return "PR creado exitosamente: " + response.json()["html_url"]
+        else:
+            raise GitFlowError("Ocurrió un error al crear el PR: " + response.text)
+
+    def create_tag(self, tag: str, commit: str) -> str:
+        response = requests.post(
+            self.get_endpoint("/git/refs"),
+            headers=self.get_headers(),
+            json={"ref": f"refs/tags/{tag}", "sha": commit},
+        )
+
+        if response.ok:
+            return "Tag creado exitosamente: " + tag
+        else:
+            raise GitFlowError("Ocurrió un error al crear el tag: " + response.text)
+
+    def get_endpoint(self, resource: str) -> str:
+        return f"{GithubRemoteAPI.API_ENDPOINT}/{self.repository}{resource}"
@@ -0,0 +1,218 @@
+version = 1
+revision = 3
+requires-python = ">=3.14"
+
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.1.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" },
+    { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" },
+    { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" },
+    { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" },
+    { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" },
+    { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", hash = "sha256:398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2", size = 328061, upload-time = "2026-04-22T15:11:27.506Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", hash = "sha256:a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613", size = 110502, upload-time = "2026-04-22T15:11:25.044Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "git-flow-envs"
+source = { editable = "." }
+dependencies = [
+    { name = "questionary" },
+    { name = "requests" },
+    { name = "rich" },
+    { name = "typer" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "questionary" },
+    { name = "requests" },
+    { name = "rich" },
+    { name = "typer" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
+]
+
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.52"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "questionary"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "prompt-toolkit" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f6/45/eafb0bba0f9988f6a2520f9ca2df2c82ddfa8d67c95d6625452e97b204a5/questionary-2.1.1.tar.gz", hash = "sha256:3d7e980292bb0107abaa79c68dd3eee3c561b83a0f89ae482860b181c8bd412d", size = 25845, upload-time = "2025-08-28T19:00:20.851Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/26/1062c7ec1b053db9e499b4d2d5bc231743201b74051c973dadeac80a8f43/questionary-2.1.1-py3-none-any.whl", hash = "sha256:a51af13f345f1cdea62347589fbb6df3b290306ab8930713bfae4d475a7d4a59", size = 36753, upload-time = "2025-08-28T19:00:19.56Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.32.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" },
+]
+
+[[package]]
+name = "rich"
+version = "15.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" },
+]
+
+[[package]]
+name = "shellingham"
+version = "1.5.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
+]
+
+[[package]]
+name = "typer"
+version = "0.25.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "click" },
+    { name = "rich" },
+    { name = "shellingham" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/51/9aed62104cea109b820bbd6c14245af756112017d309da813ef107d42e7e/typer-0.25.1.tar.gz", hash = "sha256:9616eb8853a09ffeabab1698952f33c6f29ffdbceb4eaeecf571880e8d7664cc", size = 122276, upload-time = "2026-04-30T19:32:16.964Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3f/f9/2b3ff4e56e5fa7debfaf9eb135d0da96f3e9a1d5b27222223c7296336e5f/typer-0.25.1-py3-none-any.whl", hash = "sha256:75caa44ed46a03fb2dab8808753ffacdbfea88495e74c85a28c5eefcf5f39c89", size = 58409, upload-time = "2026-04-30T19:32:18.271Z" },
+]
+
+[[package]]
+name = "urllib3"
+version = "2.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
+]
+
+[[package]]
+name = "wcwidth"
+version = "0.8.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/34/74/c6428f875774288bec1396f5bfcbc2d925700a4dad61727fd5f2b12f249d/wcwidth-0.8.2.tar.gz", hash = "sha256:91fbef97204b96a3d4d421609b80340b760cf33e26da123ff243d76b1fda8dda", size = 1466253, upload-time = "2026-06-29T18:11:11.601Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/96/42/3e5985a0a7e57de470b320c6d6a1a67c844f6737a587f3d44dd13d1819e7/wcwidth-0.8.2-py3-none-any.whl", hash = "sha256:d63947694a0539a1d51e01eda7caf800c291020e6cdd7e28ad7b14dd33ad4f85", size = 323166, upload-time = "2026-06-29T18:11:09.888Z" },
+]