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

bugfix: release not listing branches

Approved-by: Jonathan Teran

.gitignore

@@ -1,5 +1,11 @@
+# Bitbucket token
 .repository-token
 
-**/__pycache__/
+# Virtual environment
+venv/
+
+# Build folders and artifacts
+dist/
 build/
+**/__pycache__/
 **/*.egg-info/

CHANGELOG.md

@@ -1,3 +1,173 @@
+## 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)

README.md

@@ -1,3 +1,92 @@
 # 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
+    - [ ] Github: planeado
+
+  La configuración del remoto requiere tener un API Token para poder crear los PRs automáticamente.
+  El mismo se puede crear desde: *"Atlassian Account Settings" > "Security" > "Create and Manage API
+  Tokens" > "Create API Tokens with scopes"*. El token necesita el scope `write:pullrequest:bitbucket`
+
+  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`.

bitbucket-pipelines.yml

@@ -9,6 +9,5 @@ pipelines:
             - pip
           script:
             - cd $BITBUCKET_CLONE_DIR
-            - pip install --upgrade pip
             - pip install .
-            - git-flow tag $BEARER
+            - git-flow tag --token=$BEARER

pyrightconfig.json

@@ -0,0 +1,6 @@
+{
+  "exclude": [
+    "build",
+    "**/*.egg-info"
+  ]
+}

src/git_flow/__init__.py

@@ -0,0 +1,60 @@
+GitFlowError = ValueError
+
+BRANCH_TYPES = [
+    "feature",
+    "refactor",
+    "bugfix",
+    "hotfix",
+    "chore",
+    "docs",
+]
+
+COMMIT_TYPES = [
+    "feature",
+    "bugfix",
+    "hotfix",
+    "refactor",
+    "perf",
+    "docs",
+    "style",
+    "test",
+    "wip",
+]
+
+# 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"
+
+COLOR_BLACK = "\033[30m"
+COLOR_RED = "\033[31m"
+COLOR_GREEN = "\033[32m"
+COLOR_YELLOW = "\033[33m"
+COLOR_BLUE = "\033[34m"
+COLOR_5 = "\033[35m"
+COLOR_6 = "\033[36m"
+COLOR_7 = "\033[37m"
+COLOR_BLACK_BOLD = "\033[1;30m"
+COLOR_WHITE_BOLD = "\033[1;37m"
+COLOR_RESET = "\033[0m"

src/git_flow/changelog.py

@@ -0,0 +1,59 @@
+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("@")]
+            index = message.index(":")
+            commit_type = message[:index]
+            commit_message = message[index + 1 :]
+
+            content += f"- **{commit_type}**: {commit_message} [[{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)

src/git_flow/command/base.py

@@ -0,0 +1,236 @@
+from argparse import Namespace, ArgumentParser
+from abc import ABC, abstractmethod
+from os.path import isfile
+
+from git_flow import (
+    BRANCH_TYPES,
+    COLOR_BLUE,
+    COLOR_GREEN,
+    COLOR_RED,
+    COLOR_RESET,
+    COLOR_YELLOW,
+    REPOSITORY_TOKEN_FILENAME,
+    GitFlowError,
+)
+from git_flow.git import FLOWCONFIG_FILE, Git
+from git_flow.remote.base import RemoteAPI
+from git_flow.remote.bitbucket import BitbucketRemoteAPI
+from git_flow.remote.github import GithubRemoteAPI
+
+TYPE_SUCCESS = 0
+TYPE_WARNING = 1
+TYPE_ERROR = 2
+TYPE_INFO = 3
+
+
+class Command(ABC):
+    flowconfig: dict[str, str]
+
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @abstractmethod
+    def description(self) -> str:
+        pass
+
+    @abstractmethod
+    def run(self, args: Namespace = Namespace()):
+        pass
+
+    def init(self):
+        self.flowconfig = (
+            Git.get_config(FLOWCONFIG_FILE) if isfile(FLOWCONFIG_FILE) else {}
+        )
+
+    def success(self, msg: str):
+        self._print(TYPE_SUCCESS, msg)
+
+    def warning(self, msg: str):
+        self._print(TYPE_WARNING, msg)
+
+    def error(self, msg: str):
+        self._print(TYPE_ERROR, msg)
+
+    def info(self, msg: str):
+        self._print(TYPE_INFO, msg)
+
+    def prompt(
+        self,
+        prompt: str,
+        default: str | None = None,
+        persistent: bool = False,
+        strip: bool = True,
+    ) -> str:
+        onetime = not persistent
+
+        while onetime or persistent:
+            if default:
+                prompt += f" [{default}]"
+
+            prompt += ": "
+            result = input(prompt)
+            result = result.strip() if strip else result
+
+            if result:
+                return result
+            elif default is not None:
+                return default
+            elif persistent:
+                self.error("Debe ingresar un valor no vacío.")
+            else:
+                return result
+
+    def confirm(self, question: str, default: bool = True):
+        suffix = " [Y/n]: " if default else " [y/N]: "
+        answer = input(question + suffix)
+
+        return default if len(answer) == 0 else answer.startswith("y")
+
+    def choice(self, prompt: str, options: list[str]):
+        print(prompt)
+
+        for i, option in enumerate(options):
+            print(f"\t{i+1}. {option}")
+
+        selection = None
+
+        while selection is None:
+            answer = input(f"Seleccione una opción [1-{len(options)}] o escribala: ")
+
+            if answer.isdigit():
+                answer = int(answer)
+
+                if 1 <= answer and answer <= len(options):
+                    selection = options[answer - 1]
+
+                    if not self.confirm(
+                        f"Seleccionó la opción {answer} ({selection}), ¿es correcto?"
+                    ):
+                        selection = None
+                else:
+                    self.error(f"La opción {answer} está fuera del rango permitido.")
+            elif answer in options:
+                selection = answer
+            else:
+                self.error(f"La opción '{answer}' es inválida.")
+
+        return selection
+
+    def setup_parser(self, parser: ArgumentParser) -> ArgumentParser:
+        return parser
+
+    def ensure_initialized(self):
+        initialized = self.flowconfig["flow.initialized"] if self.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."
+            )
+
+    def ensure_right_branch(self):
+        branch = Git.get_current_branch()
+
+        if branch == "HEAD":
+            raise GitFlowError("No se encuentra parado sobre una rama.")
+        elif self.confirm(f"Se encuentra sobre la rama '{branch}'. ¿Es correcto?"):
+            return branch
+        else:
+            raise GitFlowError("Ejecución cancelada.")
+
+    def ensure_repository_token(self):
+        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(self, 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:
+                self.warning("Existen cambios en tu entorno de trabajo sin commitear.")
+            else:
+                raise GitFlowError("No se puede continuar con cambios pendientes.")
+
+            if not self.confirm("¿Desea continuar?", False):
+                raise GitFlowError("Ejecución abortada")
+
+    def get_branch_env_and_type(self, branch: str) -> tuple[str, str]:
+        components = branch.split("/")
+        target_branches = self.flowconfig["flow.branches"].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 (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 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 get_remote_api(self, token: str) -> RemoteAPI:
+        if "flow.remote" not in self.flowconfig:
+            raise GitFlowError("El repositorio no tiene configurado un remoto.")
+
+        [host, repository] = RemoteAPI.parse(self.flowconfig["flow.remote"])
+
+        if host == "bitbucket.org":
+            return BitbucketRemoteAPI(repository, token)
+        elif host == "github.com":
+            return GithubRemoteAPI(repository, token)
+        else:
+            raise GitFlowError("El host del repositorio remoto es inválido")
+
+    def _print(self, type: int, msg: str):
+        print(self._get_color(type) + self._get_tag(type) + " " + msg + COLOR_RESET)
+
+    def _get_color(self, type: int) -> str:
+        if type == TYPE_SUCCESS:
+            return COLOR_GREEN
+        elif type == TYPE_WARNING:
+            return COLOR_YELLOW
+        elif type == TYPE_ERROR:
+            return COLOR_RED
+        elif type == TYPE_INFO:
+            return COLOR_BLUE
+        return ""
+
+    def _get_tag(self, type: int) -> str:
+        if type == TYPE_SUCCESS:
+            return "[success]"
+        elif type == TYPE_WARNING:
+            return "[warning]"
+        elif type == TYPE_ERROR:
+            return "[error]"
+        elif type == TYPE_INFO:
+            return "[info]"
+
+        return ""

src/git_flow/command/branch.py

@@ -0,0 +1,89 @@
+from argparse import ArgumentParser, Namespace
+from git_flow import COLOR_WHITE_BOLD,  COLOR_GREEN, COLOR_RED, COLOR_RESET, GitFlowError
+from git_flow.command.base import Command
+from git_flow.git import Git
+
+
+BRANCH_FORMAT = "%(refname:short)"
+
+
+class BranchCommand(Command):
+    def name(self) -> str:
+        return "branch"
+
+    def description(self) -> str:
+        return """Lista ramas del repositorio, agrupandolas por entorno objetivo"""
+
+    def setup_parser(self, parser: ArgumentParser) -> ArgumentParser:
+        parser.add_argument(
+            "environment",
+            nargs="?",
+            help="Entorno de las ramas a listar. Puede ser vacio para listar ramas de todos los entornos, un entorno válido, o 'trash' para listar las ramas eliminadas.",
+        )
+
+        return parser
+
+    def run(self, args: Namespace = Namespace()):
+        self.ensure_initialized()
+
+        self.current_branch = Git.get_current_branch()
+        self.environments = self.flowconfig["flow.branches"].split(",")
+
+        if args.environment is None:
+            self.show_envs()
+            self.show_all_branches()
+        elif args.environment in self.environments:
+            self.show_envs()
+            self.show_env_branches(args.environment)
+        elif args.environment == "trash":
+            self.show_trash_branches()
+        else:
+            raise GitFlowError(f"'{args.environment}' no es un entorno válido.")
+
+    def show_trash_branches(self):
+        branches = self.get_trash_branches()
+
+        if not branches:
+            print("No hay ramas a mostrar.")
+            return
+
+        for branch in branches:
+            prefix = (COLOR_RED + "*") if branch == self.current_branch else " "
+            print(prefix + " " + branch + COLOR_RESET)
+
+    def get_trash_branches(self):
+        return Git("for-each-ref", "refs/heads/trash/", format=BRANCH_FORMAT).lines()
+
+    def show_all_branches(self):
+        for environment in self.environments:
+            self.show_env_branches(environment, len(self.environments) > 1)
+
+        trash = len(self.get_trash_branches())
+
+        if trash:
+            print()
+            print(COLOR_WHITE_BOLD + "Papelera: " + COLOR_RESET + str(trash) + " rama" + ("" if trash == 1 else "s"))
+
+    def show_envs(self):
+        print(COLOR_WHITE_BOLD + "Entornos" + COLOR_RESET)
+        for environment in self.environments:
+            prefix = (COLOR_GREEN + "*") if environment == self.current_branch else " "
+            print(prefix + " " + environment + COLOR_RESET)
+        print()
+
+    def show_env_branches(self, environment: str, show_env: bool = False):
+        is_first_env = environment == self.environments[0]
+        pattern = "refs/heads/" if is_first_env else "refs/heads/release/" + environment + "/"
+        pattern += "*/*"
+        exclude = ["refs/heads/trash/", "refs/heads/release/"] if is_first_env else []
+        branches = Git("for-each-ref", pattern, exclude=exclude, format=BRANCH_FORMAT).lines()
+
+        print(COLOR_WHITE_BOLD + (environment if show_env else "Ramas") + COLOR_RESET)
+
+        if not branches:
+            print("No hay ramas a mostrar.")
+            return
+
+        for branch in branches:
+            prefix = (COLOR_GREEN + "*") if branch == self.current_branch else " "
+            print(prefix + " " + branch + COLOR_RESET)

src/git_flow/command/commit.py

@@ -0,0 +1,62 @@
+from argparse import Namespace
+from datetime import datetime
+from git_flow import COMMIT_TYPES, GitFlowError
+from git_flow.command.base import Command
+from git_flow.git import Git
+
+
+class CommitCommand(Command):
+    def name(self) -> str:
+        return "commit"
+
+    def description(self) -> str:
+        return """Crea un commit siguiendo el formato de Conventional Commits"""
+
+    def run(self, args: Namespace = Namespace()):
+        self.ensure_initialized()
+        branch = self.ensure_right_branch()
+
+        if not self._has_files_staged():
+            self.warning("No hay cambios en el indice para commitear.")
+            if self.confirm("¿Desea agregar la carpeta actual?"):
+                Git("add", ".").exec(print="Agregando cambios")
+            else:
+                raise GitFlowError(
+                    "Debe agregar algún cambio al indice para continuar."
+                )
+
+        commit_type = self.choice("Tipo de commit", COMMIT_TYPES)
+        commit_message = self.prompt(
+            "Mensaje (máximo recomendado: 100 caracteres)", persistent=True
+        )
+        message = commit_type + ": " + commit_message
+
+        if branch.startswith("wip/"):
+            original_branch = branch.removeprefix("wip/")
+            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 + "/" + suffix, move=True).exec(print="Backup de rama WIP")
+        else:
+            if commit_type == "wip":
+                Git("switch", "wip/" + branch, create=True).exec(print="Creando nueva rama WIP")
+
+            Git("commit", m=message).exec(print="Creando commit")
+
+    def _has_files_staged(self):
+        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

src/git_flow/command/init.py

@@ -0,0 +1,115 @@
+from argparse import Namespace
+from git_flow import GitFlowError
+from git_flow.command.base import Command
+from git_flow.git import FLOWCONFIG_FILE, Git
+
+
+class InitCommand(Command):
+    def name(self) -> str:
+        return "init"
+
+    def description(self) -> str:
+        return """Inicializa el repositorio para utilizar git-flow"""
+
+    def run(self, args: Namespace = Namespace()):
+        self._ensure_is_repository()
+        self._ensure_not_already_initialized()
+
+        branches = self._setup_flow_branches()
+        remote = self._setup_flow_remote()
+
+        flowconfig = {
+            "flow.initialized": "true",
+            "flow.branches": ",".join(branches),
+        }
+
+        if remote:
+            flowconfig["flow.remote"] = remote
+
+        Git.set_config(flowconfig, FLOWCONFIG_FILE)
+        Git("add", FLOWCONFIG_FILE).exec()
+        Git("commit", message="feature: initialize git-flow").exec()
+
+        self._ensure_all_flow_branches_exist(branches, remote)
+
+    def _ensure_is_repository(self):
+        if not Git.is_repository():
+            self.warning("El directorio actual no es un repositorio.")
+
+            if not self.confirm("¿Desea inicializarlo?"):
+                raise GitFlowError(
+                    "No se puede continuar sin inicializar el repositorio"
+                )
+
+            Git("init").exec()
+
+    def _ensure_not_already_initialized(self):
+        if not self.flowconfig:
+            return
+        elif self.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(self):
+        self.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"."""
+        )
+
+        branches = list(
+            map(lambda b: b.strip(), self.prompt("Ramas", "main").split(","))
+        )
+
+        if not all(branches):
+            raise GitFlowError("No puede ingresar una rama vacia")
+
+        return branches
+
+    def _setup_flow_remote(self):
+        self.info(
+            """Puede elegir o crear un repositorio remoto para generar automáticamente PRs"""
+        )
+
+        remote = None
+
+        if self.confirm("¿Configurar repositorio remoto?"):
+            remotes = Git("remote").lines(print="Listando remotos disponibles")
+
+            if not remotes:
+                self.info("No tiene ningún repositorio remoto, se creará uno.")
+
+                url = self.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:
+                self.info("Tiene más de un remoto, seleccione el que va a utilizar.")
+                remote = self.choice("Remoto", remotes)
+
+        return remote
+
+    def _ensure_all_flow_branches_exist(self, branches: list[str], remote: str | None):
+        existing_branches = Git.get_branches()
+
+        if not all(map(lambda b: b in existing_branches, branches)):
+            self.warning("Algunas de las ramas de entornos expecificadas no existen.")
+            self.info("Debe indicar sobre que rama se crearán las ramas de entorno.")
+
+            target_branch = self.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"
+                        )

src/git_flow/command/merge.py

@@ -0,0 +1,91 @@
+from argparse import Namespace
+from git_flow import GitFlowError
+from git_flow.changelog import Changelog
+from git_flow.command.base import Command
+from git_flow.git import Git
+
+
+class MergeCommand(Command):
+    def name(self) -> str:
+        return "merge"
+
+    def description(self) -> str:
+        return """Realiza el merge de la rama, o crea el PR para hacerlo si tiene un remoto configurado"""
+
+    def run(self, args: Namespace = Namespace()):
+        self.ensure_initialized()
+
+        branch = self.ensure_right_branch()
+        (target, _) = self.get_branch_env_and_type(branch)
+
+        if "flow.remote" in self.flowconfig:
+            remote = self.flowconfig["flow.remote"]
+            token = self.ensure_repository_token()
+            self.run_remote(remote, token, branch, target)
+        else:
+            self.run_local(branch, target)
+
+    def run_remote(self, remote: str, token: str, branch: str, target: str):
+        self.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")
+
+        self.check_merge_conflicts(target)
+        self.show_commits_to_merge(target)
+
+        if self.confirm(f"¿Crear PR de '{branch}' a '{target}'?"):
+            Git("push", remote, branch, set_upstream=True).exec(
+                print="Subiendo rama al remoto para crear PR"
+            )
+
+            self.create_pull_request(token, branch, target)
+
+    def run_local(self, branch: str, target: str):
+        self.ensure_clean_worktree(False)
+        self.check_merge_conflicts(target)
+        self.show_commits_to_merge(target)
+
+        if self.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(self, 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(self, 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:
+            self.error(f"La rama actual tiene conflictos con {target}")
+            self.info(
+                f"""Se recomienda mergear {target} a la rama actual, resolver los conflictos localmente, y ejecutar nuevamente este comando"""
+            )
+            raise GitFlowError("Ejecución abortada.")
+        else:
+            self.success("No se detectaron merge conflicts.")
+
+    def create_pull_request(self, token: str, branch: str, target: str):
+        changelog = Changelog()
+
+        message = self.get_remote_api(token).create_pull_request(
+            branch,
+            target,
+            branch.replace("/", ": ").replace("-", " "),
+            changelog.generate_content(target, branch),
+        )
+
+        self.success(message)

src/git_flow/command/new.py

@@ -0,0 +1,49 @@
+from argparse import Namespace
+from git_flow import BRANCH_TYPES
+from git_flow.command.base import Command
+from git_flow.git import Git
+
+
+class NewCommand(Command):
+    def name(self) -> str:
+        return "new"
+
+    def description(self) -> str:
+        return """Crea una nueva rama siguiendo conventional branches"""
+
+    def run(self, args: Namespace = Namespace()):
+        self.ensure_initialized()
+        self.ensure_right_branch()
+
+        self.info("Se creará una nueva rama de trabajo sobre la rama actual.")
+        self.info("Debe seleccionar el tipo de cambio a realizar.")
+
+        branch_type = self.choice("Tipos de cambio", BRANCH_TYPES)
+        new_branch = self._get_unique_branch_name(branch_type)
+
+        if self.confirm(f"¿Crear rama '{new_branch}' sobre la rama actual?"):
+            Git("switch", new_branch, create=True).exec(print="Creando nueva rama")
+
+    def _get_unique_branch_name(self, branch_type: str) -> str:
+        self.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 = self.prompt(
+                "Palabras clave del cambio (por ejemplo: 'create worker form')",
+                persistent=True,
+            )
+
+            keywords = filter(lambda k: len(k) > 0, keywords.split(" "))
+            branch = branch_type + "/" + "-".join(keywords)
+
+            if branch in branches:
+                self.error(
+                    f"La rama '{branch}' ya existe, cambie las palabras claves para generar otra"
+                )
+                branch = None
+
+        return branch

src/git_flow/command/release.py

@@ -0,0 +1,94 @@
+from argparse import ArgumentParser, Namespace
+from git_flow import COMMIT_TYPES, GitFlowError
+from git_flow.command.base import Command
+from git_flow.git import Git
+
+
+class ReleaseCommand(Command):
+    def name(self) -> str:
+        return "release"
+
+    def description(self) -> str:
+        return """Realiza el merge de la rama, o crea el PR para hacerlo si tiene un remoto configurado"""
+
+    def setup_parser(self, parser: ArgumentParser) -> ArgumentParser:
+        parser.add_argument(
+            "--group",
+            nargs="?",
+            help="Agrupar release",
+        )
+
+        return parser
+
+    def run(self, args: Namespace = Namespace()):
+        self.ensure_initialized()
+
+        branch = self.ensure_right_branch()
+        envs = self.flowconfig["flow.branches"].split(",")
+        (env, _) = self.get_branch_env_and_type(branch)
+
+        if env == envs[-1]:
+            raise GitFlowError(
+                "No se puede hacer release de una rama en el ultimo entorno."
+            )
+
+        has_remote = "flow.remote" in self.flowconfig
+
+        self.ensure_clean_worktree(has_remote)
+
+        next_env = envs[envs.index(env) + 1]
+        next_branch = (
+            branch.replace(f"/{env}/", f"/{next_env}/")
+            if branch.startswith("release/")
+            else f"release/{next_env}/{branch}"
+        )
+
+        base = Git.get_first_fork_point(branch, env)
+        commits = Git("log", base + ".." , 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)
+
+        group = args.group
+
+        if not group:
+            if self.confirm("¿Desea agrupar este release con otra rama?", False):
+                group = self.choice("Grupo release: ", Git.get_branches("release/" + next_env + "/"))
+            else:
+                group = next_env
+
+        if has_remote:
+            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 self.confirm(
+            f"¿Desea reemplazar los {len(commits)} commits de la rama por uno solo?",
+            False
+        ):
+            self.info("Debe ingresar el mensaje del commit a crear.")
+
+            commit_type = self.choice("Tipo de commit", COMMIT_TYPES[:-1])
+            commit_message = self.prompt(
+                "Mensaje (máximo recomendado: 100 caracteres)", persistent=True
+            )
+            message = commit_type + ": " + commit_message
+
+            Git("switch", next_branch, base, 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")
+
+        Git("rebase", base, next_branch, onto=group).exec(
+            print="Moviendo cambios hacia el siguiente ambiente"
+        )

src/git_flow/command/tag.py

@@ -0,0 +1,107 @@
+from argparse import ArgumentParser, Namespace
+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.command.base import Command
+from git_flow.git import Git
+
+
+class TagCommand(Command):
+    def name(self) -> str:
+        return "tag"
+
+    def description(self) -> str:
+        return """Crea un nuevo tag para el último merge."""
+
+    def run(self, args: Namespace = Namespace()):
+        self.ensure_initialized()
+
+        envs = self.flowconfig["flow.branches"].split(",")
+        target = Git.get_current_branch()
+
+        if target not in envs:
+            raise GitFlowError("Solo se pueden taggear commits en ramas principales.")
+
+        branch = Git("show", self.get_last_merge_commit() + "^2", patch=False, format="%h").firstline()
+        base = Git.get_first_fork_point(branch, target)
+        commits = Git("log", base + ".." + branch, format="%s").lines()
+        next_tag = self.get_next_tag_from_commits(commits, target)
+
+        if not next_tag:
+            self.info(
+                "Los cambios realizados no implican un salto de versión, se mantiene la anterior."
+            )
+            return
+
+        (token, ci) = self.get_token_and_ci(args)
+        changelog = Changelog()
+
+        changelog.update(next_tag, base, 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")
+            self.success(self.get_remote_api(token).create_tag(next_tag, tag_commit))
+        else:
+            Git("tag", next_tag, tag_commit).exec(print="Creando tag localmente")
+
+    def get_token_and_ci(self, args: Namespace):
+        try:
+            return (self.ensure_repository_token(), False)
+        except GitFlowError:
+            return (args.token, True)
+
+    def setup_parser(self, parser: ArgumentParser) -> ArgumentParser:
+        parser.add_argument("--token")
+
+        return parser
+
+    def get_last_merge_commit(self):
+        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(self, 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(self, 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
+
+        return None if increment == SEMVER_SKIP else f"v{major}.{minor}.{patch}{suffix}"

src/git_flow/git.py

@@ -1,68 +1,86 @@
 import subprocess
 
-from .io import *
+from git_flow.io import *
 
 
-class Status:
+FLOWCONFIG_FILE = ".flowconfig"
-    worktree: str
-    index: str
-    file: str
 
-    def __init__(self, line: str) -> None:
+CHANGELOG_FILE = "CHANGELOG.md"
-        self.worktree = line[0]
+
-        self.index = line[1]
+BUMP_VERSION = "chore: bump version and update CHANGELOG.md [skip ci]"
-        self.file = line[3:].strip("\n")
 
 
 class Git:
-    FLOWCONFIG_FILE = ".flowconfig"
+    class Status:
-    CHANGELOG_FILE = "CHANGELOG.md"
+        worktree: str
-    BUMP_VERSION = "chore: bump version and update CHANGELOG.md [skip ci]"
+        index: str
+        file: str
+
+        def __init__(self, line: str) -> None:
+            self.worktree = line[0]
+            self.index = line[1]
+            self.file = line[3:].strip("\n")
 
     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_FILE, **kwargs)
 
     @staticmethod
     def get_current_branch():
         return Git("rev-parse", "HEAD", abbrev_ref=True).firstline()
 
     @staticmethod
-    def get_branches():
+    def get_branches(prefix: str = ""):
-        return Git._get_references("heads")
+        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)
 
     @staticmethod
     def get_first_fork_point(branch: str, env: str):
-        boundary_commits = list(filter(
+        # Lista de commits alcanzables por el entorno (por ejemplo, dev),
-            lambda c: c.startswith("-"), # boundary commits
+        env_commits = Git("rev-list", env + "..." + branch, first_parent=True).lines()
-            Git("rev-list", env + "..." + branch, topo_order=True, boundary=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 + "/"
+        prefix = "refs/" + kind
-        return map(
+        return Git("for-each-ref", prefix + "**", format="%(refname:short)").lines()
-            lambda r: r.removeprefix(prefix),
-            Git("for-each-ref", prefix + "*", format="%(refname)").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
+
+    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 +92,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 +108,47 @@ class Git:
 
         self.command += args
 
-    def lines(self, strip: bool = True):
+    def lines(self, strip: bool = True, **kwargs):
-        process = subprocess.run(self.command, capture_output=True, text=True)
+        process = self._get(**kwargs)
-
-        self.__print_process(process.stdout, process.stderr)
-
-        if self.check_returncode:
-            process.check_returncode()
-
         lines = process.stdout.splitlines()
 
         return lines if not strip else list(map(lambda l: l.strip(), lines))
 
-    def firstline(self):
+    def firstline(self, **kwargs: bool):
-        lines = self.lines()
+        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):
+        return process
-        process = subprocess.run(self.command, capture_output=True, text=True)
 
-        self.__print_process(process.stdout, process.stderr)
 
-        return process.returncode
+    def _run(self, print: str|None = None, check: bool = True):
+        process = subprocess.run(self.command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
-    def without_checking(self):
+        if print is not None:
-        self.check_returncode = False
+            self._print_process("", "", title=print)
 
-        return self
+        if check:
+            process.check_returncode()
 
-    def __print_process(self, stdout: str, stderr: str):
+        return process
+
+    def _print_process(self, stdout: str, stderr: str, title: str):
         command = []
 
         for arg in self.command:
@@ -134,10 +160,12 @@ class Git:
 
             command.append(arg)
 
-        print(COLOR_YELLOW + "> " + " ".join(command) + COLOR_RESET)
+        title = title or "Ejecutando"
+        print(COLOR_YELLOW + "| " + title + COLOR_RESET)
+        print(COLOR_YELLOW + "| $ " + " ".join(command) + COLOR_RESET)
 
         for line in stdout.splitlines():
-            print(COLOR_BLUE + "< " + line + COLOR_RESET)
+            print(COLOR_YELLOW + "| " + COLOR_RESET + "[out] " + line)
 
         for line in stderr.splitlines():
-            print(COLOR_RED + "! " + line + COLOR_RESET)
+            print(COLOR_YELLOW + "| " + COLOR_RED + "[err] " + line + COLOR_RESET)

src/git_flow/io.py

@@ -1,14 +1,6 @@
 import sys
 
-
+from git_flow import COLOR_BLACK_BOLD, COLOR_BLUE, COLOR_GREEN, COLOR_RED, COLOR_RESET, COLOR_YELLOW
-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 confirm(prompt, default: bool = True):
     user_input = input(prompt + (" [Y/n]: " if default else " [y/N]: "))

src/git_flow/main.py

@@ -1,17 +1,61 @@
 #!/usr/bin/env python3
 
-import os
-import sys
-import datetime
-import requests
 import locale
+from argparse import Namespace, ArgumentParser
 
-from .git import Git
+from git_flow import GitFlowError
-from .io import *
+from git_flow.command.base import Command
+from git_flow.command.branch import BranchCommand
+from git_flow.command.commit import CommitCommand
+from git_flow.command.init import InitCommand
+from git_flow.command.merge import MergeCommand
+from git_flow.command.new import NewCommand
+from git_flow.command.release import ReleaseCommand
+from git_flow.command.tag import TagCommand
+from git_flow.io import *
 
 
-REPOSITORY_TOKEN_PATH=".repository-token"
+REPOSITORY_TOKEN_PATH = ".repository-token"
-LOCALE = 'es_AR.UTF-8'
+LOCALE = "es_AR.UTF-8"
+
+
+class GitFlowCommand(Command):
+    commands: tuple[Command, ...]
+
+    def __init__(self, *args: Command) -> None:
+        self.commands = args
+
+    def name(self) -> str:
+        return "git-flow"
+
+    def description(self) -> str:
+        return """Git flow es una herramienta para automatizar un workflow siguiendo conventional commits, conventional branch y semver."""
+
+    def setup_parser(self, parser: ArgumentParser) -> ArgumentParser:
+        subparsers = parser.add_subparsers(
+            title="comandos", dest="command", required=True
+        )
+
+        for command in self.commands:
+            subparser = subparsers.add_parser(
+                command.name(), description=command.description()
+            )
+            command.setup_parser(subparser)
+
+        return parser
+
+    def get_parser(self) -> ArgumentParser:
+        parser = ArgumentParser(self.name(), description=self.description())
+
+        return self.setup_parser(parser)
+
+    def run(self, args: Namespace = Namespace()):
+        args = self.get_parser().parse_args()
+
+        for command in self.commands:
+            if command.name() == args.command:
+                command.init()
+                return command.run(args)
 
 
 def main():
@@ -20,639 +64,24 @@ def main():
     except locale.Error as e:
         print_warning(f"No se pudo configurar el locale '{LOCALE}': {e}")
 
-    args = sys.argv
+    command = GitFlowCommand(
-
+        InitCommand(),
-    if len(args) < 2:
+        NewCommand(),
-        print_error("missing command")
+        CommitCommand(),
-        return
+        MergeCommand(),
-
+        TagCommand(),
-    command = args[1]
+        ReleaseCommand(),
-
+        BranchCommand()
+    )
     try:
-        if command == "new":
+        command.run()
-            new_command()
+    except GitFlowError as e:
-        elif command == "init":
+        command.error(str(e))
-            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)
     except Exception as e:
-        print_error(f"Ocurrio un error al ejecutar el comando: {e}")
+        command.error("Ocurrió un error inesperado: " + str(e))
 
+    return
 
 
-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} por [{username}]({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()

src/git_flow/remote/base.py

@@ -0,0 +1,75 @@
+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()
+        invalid_url_error = GitFlowError(f"La URL del remoto {remote} es inválida: {url}")
+        url_type = None
+
+        if url.startswith("git@"):
+            url_type = "ssh"
+        elif url.startswith("http://") or url.startswith("https://"):
+            url_type = "https"
+        else:
+            raise invalid_url_error
+
+        if url_type == "ssh":
+            # git@host:user/repo[.git]
+            at_pos = url.index("@")
+            colon_pos = url.index(":")
+            host = url[at_pos+1:colon_pos]
+            repository = url[colon_pos+1:]
+        else:
+            # https://host/user/repo[.git]
+            host_start = url.index("://") + 3
+            uri_start = url.index("/", host_start)
+            host = url[host_start:uri_start]
+            repository = url[uri_start+1:]
+
+        # Esto permite configurar hosts "imaginarios" para permitir el uso de multiples claves ssh
+        if host.endswith(".bitbucket.org"):
+            host = "bitbucket.org"
+        elif host.endswith(".github.com"):
+            host = "github.com"
+
+        if host not in SUPPORTED_REMOTE_APIS:
+            raise GitFlowError("El host del repositorio remoto es inválido")
+
+        repository.removesuffix(".git")
+
+        return [host, repository]
+
+
+    @abstractmethod
+    def create_pull_request(
+        self,
+        source: str,
+        destination: str,
+        title: str | None = None,
+        description: str | None = None,
+    ) -> 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,
+        }

src/git_flow/remote/bitbucket.py

@@ -0,0 +1,47 @@
+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,
+    ):
+        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": True,
+            },
+        )
+
+        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}"

src/git_flow/remote/github.py

@@ -0,0 +1,21 @@
+from git_flow import GitFlowError
+from git_flow.remote.base import RemoteAPI
+
+
+class GithubRemoteAPI(RemoteAPI):
+    API_ENDPOINT = "https://github.com"
+
+    def create_pull_request(
+        self,
+        source: str,
+        destination: str,
+        title: str | None = None,
+        description: str | None = None,
+    ) -> str:
+        raise GitFlowError("not implemented yet!")
+
+    def create_tag(self, tag: str, commit: str) -> str:
+        raise GitFlowError("not implemented yet!")
+
+    def get_endpoint(self, resource: str) -> str:
+        return GithubRemoteAPI.API_ENDPOINT