baobab-ai-dev-git 0.1.0__py3-none-any.whl

baobab_ai_dev_git/__init__.py

@@ -0,0 +1,75 @@
+"""Librairie de gestion Git pour l'écosystème Baobab AI Dev."""
+
+from baobab_ai_dev_git.branch.branch_name_builder import BranchNameBuilder
+from baobab_ai_dev_git.branch.branch_name_validator import BranchNameValidator
+from baobab_ai_dev_git.branch.branch_service import BranchService
+from baobab_ai_dev_git.exceptions import (
+    BranchAlreadyExistsError,
+    BranchNotFoundError,
+    GithubIntegrationError,
+    GithubOperationError,
+    GitOperationError,
+    InvalidBranchHierarchyError,
+    InvalidBranchNameError,
+    InvalidPullRequestTargetError,
+    MergeNotAllowedError,
+    RepositoryDirtyError,
+)
+from baobab_ai_dev_git.github import (
+    GithubCheckRunInfo,
+    GithubClientPort,
+    GithubPullRequestAdapter,
+    GithubPullRequestApiClient,
+    GithubPullRequestInfo,
+    GithubRepositoryAdapter,
+    GithubRepositoryApiClient,
+    GithubRepositoryInfo,
+)
+from baobab_ai_dev_git.policy.merge_policy_service import MergePolicyService
+from baobab_ai_dev_git.pull_request.pull_request_service import PullRequestService
+from baobab_ai_dev_git.pull_request.pull_request_validator import PullRequestValidator
+from baobab_ai_dev_git.report import GitComplianceReport, GitComplianceReportBuilder
+from baobab_ai_dev_git.result import (
+    BranchValidationResult,
+    GitOperationResult,
+    MergeEligibilityResult,
+    PullRequestValidationResult,
+    SerializableResult,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "BranchAlreadyExistsError",
+    "BranchNameBuilder",
+    "BranchNameValidator",
+    "BranchNotFoundError",
+    "BranchService",
+    "BranchValidationResult",
+    "GitComplianceReport",
+    "GitComplianceReportBuilder",
+    "GitOperationError",
+    "GitOperationResult",
+    "GithubCheckRunInfo",
+    "GithubClientPort",
+    "GithubIntegrationError",
+    "GithubOperationError",
+    "GithubPullRequestAdapter",
+    "GithubPullRequestApiClient",
+    "GithubPullRequestInfo",
+    "GithubRepositoryAdapter",
+    "GithubRepositoryApiClient",
+    "GithubRepositoryInfo",
+    "InvalidBranchHierarchyError",
+    "InvalidBranchNameError",
+    "InvalidPullRequestTargetError",
+    "MergeEligibilityResult",
+    "MergeNotAllowedError",
+    "MergePolicyService",
+    "PullRequestService",
+    "PullRequestValidationResult",
+    "PullRequestValidator",
+    "RepositoryDirtyError",
+    "SerializableResult",
+    "__version__",
+]

baobab_ai_dev_git/branch/__init__.py

@@ -0,0 +1 @@
+"""Construction de noms de branches Git conformes."""

baobab_ai_dev_git/branch/branch_hierarchy_validator.py

@@ -0,0 +1,83 @@
+"""Valide la hiérarchie parent/enfant entre branches Git."""
+
+from baobab_ai_dev_git.branch.branch_name import BranchName
+from baobab_ai_dev_git.branch.branch_name_parser import BranchNameParser
+from baobab_ai_dev_git.branch.branch_type import BranchType
+from baobab_ai_dev_git.exceptions.invalid_branch_hierarchy_error import (
+    InvalidBranchHierarchyError,
+)
+
+
+class BranchHierarchyValidator:
+    """Vérifie qu'une branche enfant respecte la hiérarchie US → FEAT → BL."""
+
+    _ALLOWED_CHILDREN: dict[BranchType, frozenset[BranchType]] = {
+        BranchType.MAIN: frozenset({BranchType.USER_STORY}),
+        BranchType.USER_STORY: frozenset({BranchType.FEATURE}),
+        BranchType.FEATURE: frozenset({BranchType.BACKLOG}),
+        BranchType.BACKLOG: frozenset(),
+        BranchType.UNKNOWN: frozenset(),
+    }
+
+    def __init__(self, parser: BranchNameParser | None = None) -> None:
+        """Initialise le validateur.
+
+        :param parser: Parseur injecté ; instance par défaut si absent.
+        :type parser: BranchNameParser | None
+        """
+        self._parser: BranchNameParser = parser or BranchNameParser()
+
+    def validate(self, parent_raw_name: str, child_raw_name: str) -> None:
+        """Valide la relation hiérarchique entre deux branches.
+
+        :param parent_raw_name: Nom de la branche parente.
+        :type parent_raw_name: str
+        :param child_raw_name: Nom de la branche enfant.
+        :type child_raw_name: str
+        :raises InvalidBranchHierarchyError: Si la hiérarchie est invalide.
+        """
+        parent = self._parser.parse(parent_raw_name)
+        child = self._parser.parse(child_raw_name)
+
+        if parent.branch_type == BranchType.UNKNOWN:
+            msg = f"Branche parente non reconnue : '{parent.raw_name}'."
+            raise InvalidBranchHierarchyError(msg, parent.raw_name, child.raw_name)
+
+        if child.branch_type == BranchType.UNKNOWN:
+            msg = f"Branche enfant non reconnue : '{child.raw_name}'."
+            raise InvalidBranchHierarchyError(msg, parent.raw_name, child.raw_name)
+
+        allowed = self._ALLOWED_CHILDREN[parent.branch_type]
+        if child.branch_type not in allowed:
+            msg = (
+                f"Hiérarchie invalide : '{child.raw_name}' ne peut pas être créée "
+                f"depuis '{parent.raw_name}'."
+            )
+            raise InvalidBranchHierarchyError(msg, parent.raw_name, child.raw_name)
+
+        self._validate_identifier_consistency(parent, child)
+
+    def _validate_identifier_consistency(self, parent: BranchName, child: BranchName) -> None:
+        """Vérifie la cohérence des identifiants entre parent et enfant.
+
+        :param parent: Branche parente parsée.
+        :type parent: BranchName
+        :param child: Branche enfant parsée.
+        :type child: BranchName
+        :raises InvalidBranchHierarchyError: Si les identifiants sont incohérents.
+        """
+        if child.branch_type == BranchType.FEATURE:
+            if child.user_story_id != parent.user_story_id:
+                msg = (
+                    f"La feature '{child.raw_name}' doit appartenir à "
+                    f"la user story '{parent.user_story_id}'."
+                )
+                raise InvalidBranchHierarchyError(msg, parent.raw_name, child.raw_name)
+
+        if child.branch_type == BranchType.BACKLOG:
+            if child.feature_id != parent.feature_id:
+                msg = (
+                    f"Le backlog '{child.raw_name}' doit appartenir à "
+                    f"la feature '{parent.feature_id}'."
+                )
+                raise InvalidBranchHierarchyError(msg, parent.raw_name, child.raw_name)

baobab_ai_dev_git/branch/branch_name.py

@@ -0,0 +1,31 @@
+"""Représentation structurée d'un nom de branche Git."""
+
+from dataclasses import dataclass
+
+from baobab_ai_dev_git.branch.branch_type import BranchType
+
+
+@dataclass(frozen=True, slots=True)
+class BranchName:
+    """Nom de branche Git parsé et typé.
+
+    :param raw_name: Chaîne brute telle que fournie par Git.
+    :type raw_name: str
+    :param branch_type: Type de branche détecté.
+    :type branch_type: BranchType
+    :param user_story_id: Identifiant US extrait, le cas échéant.
+    :type user_story_id: str | None
+    :param feature_id: Identifiant feature extrait, le cas échéant.
+    :type feature_id: str | None
+    :param backlog_id: Identifiant backlog extrait, le cas échéant.
+    :type backlog_id: str | None
+    :param slug: Partie descriptive normalisée, le cas échéant.
+    :type slug: str | None
+    """
+
+    raw_name: str
+    branch_type: BranchType
+    user_story_id: str | None = None
+    feature_id: str | None = None
+    backlog_id: str | None = None
+    slug: str | None = None

baobab_ai_dev_git/branch/branch_name_builder.py

@@ -0,0 +1,120 @@
+"""Génère des noms de branches Git conformes aux conventions du projet."""
+
+import re
+import unicodedata
+
+from baobab_ai_dev_core.domain.entities.backlog import Backlog
+from baobab_ai_dev_core.domain.entities.feature import Feature
+from baobab_ai_dev_core.domain.entities.user_story import UserStory
+
+_ID_PATTERN: re.Pattern[str] = re.compile(r"^[A-Z]+-\d+$")
+_FORBIDDEN_SLUG_CHARS: re.Pattern[str] = re.compile(r"[^a-z0-9-]+")
+_MULTI_HYPHEN: re.Pattern[str] = re.compile(r"-{2,}")
+
+
+class BranchNameBuilder:
+    """Construit des noms de branches Git à partir d'objets métier.
+
+    Les slugs produits sont déterministes : minuscules, sans accents,
+    caractères spéciaux supprimés, espaces convertis en tirets.
+    """
+
+    def build_user_story_branch(self, user_story: UserStory) -> str:
+        """Construit le nom de branche d'une user story.
+
+        :param user_story: User story source.
+        :type user_story: UserStory
+        :return: Nom de branche (ex. ``us/US-001-initialiser-module-git``).
+        :rtype: str
+        :raises ValueError: Si l'identifiant ou le titre est absent ou invalide.
+        """
+        identifier = self._require_identifier(str(user_story.code), "user_story")
+        slug = self.normalize_slug(str(user_story.title))
+        return f"us/{identifier}-{slug}"
+
+    def build_feature_branch(self, feature: Feature) -> str:
+        """Construit le nom de branche d'une feature.
+
+        :param feature: Feature source.
+        :type feature: Feature
+        :return: Nom de branche (ex. ``feat/US-001/FEAT-001-gestion-branches``).
+        :rtype: str
+        :raises ValueError: Si un identifiant ou le titre est absent ou invalide.
+        """
+        feature_id = self._require_identifier(str(feature.code), "feature")
+        user_story_code = feature.branch_name.user_story_code
+        if user_story_code is None:
+            msg = "Le code user story parent est introuvable sur la branche de la feature."
+            raise ValueError(msg)
+        user_story_id = self._require_identifier(str(user_story_code), "user_story")
+        slug = self.normalize_slug(str(feature.title))
+        return f"feat/{user_story_id}/{feature_id}-{slug}"
+
+    def build_backlog_branch(self, backlog: Backlog) -> str:
+        """Construit le nom de branche d'un backlog.
+
+        :param backlog: Backlog source.
+        :type backlog: Backlog
+        :return: Nom de branche (ex. ``bl/FEAT-001/BL-001-validator``).
+        :rtype: str
+        :raises ValueError: Si un identifiant ou le titre est absent ou invalide.
+        """
+        backlog_id = self._require_identifier(str(backlog.code), "backlog")
+        feature_code = backlog.branch_name.feature_code
+        if feature_code is None:
+            msg = "Le code feature parent est introuvable sur la branche du backlog."
+            raise ValueError(msg)
+        feature_id = self._require_identifier(str(feature_code), "feature")
+        slug = self.normalize_slug(str(backlog.title))
+        return f"bl/{feature_id}/{backlog_id}-{slug}"
+
+    def normalize_slug(self, title: str) -> str:
+        """Normalise un titre en slug Git conforme.
+
+        :param title: Titre brut à normaliser.
+        :type title: str
+        :return: Slug en minuscules sans caractères interdits.
+        :rtype: str
+        :raises ValueError: Si le titre est vide ou ne produit aucun slug valide.
+        """
+        if not title or not title.strip():
+            msg = "Le titre ne peut pas être vide."
+            raise ValueError(msg)
+
+        normalized = unicodedata.normalize("NFKD", title.strip())
+        ascii_title = normalized.encode("ascii", "ignore").decode("ascii")
+        lowered = ascii_title.lower()
+        with_hyphens = lowered.replace(" ", "-").replace("_", "-")
+        cleaned = _FORBIDDEN_SLUG_CHARS.sub("", with_hyphens)
+        collapsed = _MULTI_HYPHEN.sub("-", cleaned).strip("-")
+
+        if not collapsed:
+            msg = "Le titre ne produit aucun slug valide après normalisation."
+            raise ValueError(msg)
+
+        return collapsed
+
+    def _require_identifier(self, value: str, field_name: str) -> str:
+        """Valide et retourne un identifiant métier.
+
+        :param value: Identifiant brut.
+        :type value: str
+        :param field_name: Nom du champ pour le message d'erreur.
+        :type field_name: str
+        :return: Identifiant validé.
+        :rtype: str
+        :raises ValueError: Si l'identifiant est absent ou mal formé.
+        """
+        if not value or not value.strip():
+            msg = f"L'identifiant {field_name} est obligatoire."
+            raise ValueError(msg)
+
+        candidate = value.strip().upper()
+        if not _ID_PATTERN.match(candidate):
+            msg = (
+                f"L'identifiant {field_name} '{value}' est invalide "
+                f"(format attendu : PREFIX-NUM, ex. US-001)."
+            )
+            raise ValueError(msg)
+
+        return candidate

baobab_ai_dev_git/branch/branch_name_parser.py

@@ -0,0 +1,62 @@
+"""Analyse un nom de branche Git brut en objet structuré."""
+
+import re
+
+from baobab_ai_dev_git.branch.branch_name import BranchName
+from baobab_ai_dev_git.branch.branch_type import BranchType
+
+_ID: str = r"[A-Z]+-\d+"
+_RE_USER_STORY: re.Pattern[str] = re.compile(rf"^us/({_ID})-(.+)$")
+_RE_FEATURE: re.Pattern[str] = re.compile(rf"^feat/({_ID})/({_ID})-(.+)$")
+_RE_BACKLOG: re.Pattern[str] = re.compile(rf"^bl/({_ID})/({_ID})-(.+)$")
+
+
+class BranchNameParser:
+    """Parse une chaîne de branche Git en ``BranchName`` structuré."""
+
+    def parse(self, raw_name: str) -> BranchName:
+        """Analyse un nom de branche brut.
+
+        :param raw_name: Nom de branche tel que retourné par Git.
+        :type raw_name: str
+        :return: Objet ``BranchName`` avec type et identifiants extraits.
+        :rtype: BranchName
+        """
+        normalized = raw_name.strip()
+
+        if normalized == "main":
+            return BranchName(raw_name=normalized, branch_type=BranchType.MAIN)
+
+        backlog_match = _RE_BACKLOG.match(normalized)
+        if backlog_match is not None:
+            feature_id, backlog_id, slug = backlog_match.groups()
+            return BranchName(
+                raw_name=normalized,
+                branch_type=BranchType.BACKLOG,
+                feature_id=feature_id,
+                backlog_id=backlog_id,
+                slug=slug,
+            )
+
+        feature_match = _RE_FEATURE.match(normalized)
+        if feature_match is not None:
+            user_story_id, feature_id, slug = feature_match.groups()
+            return BranchName(
+                raw_name=normalized,
+                branch_type=BranchType.FEATURE,
+                user_story_id=user_story_id,
+                feature_id=feature_id,
+                slug=slug,
+            )
+
+        user_story_match = _RE_USER_STORY.match(normalized)
+        if user_story_match is not None:
+            user_story_id, slug = user_story_match.groups()
+            return BranchName(
+                raw_name=normalized,
+                branch_type=BranchType.USER_STORY,
+                user_story_id=user_story_id,
+                slug=slug,
+            )
+
+        return BranchName(raw_name=normalized, branch_type=BranchType.UNKNOWN)

baobab_ai_dev_git/branch/branch_name_validator.py

@@ -0,0 +1,77 @@
+"""Valide strictement les noms de branches Git."""
+
+from baobab_ai_dev_git.branch.branch_name import BranchName
+from baobab_ai_dev_git.branch.branch_name_parser import BranchNameParser
+from baobab_ai_dev_git.branch.branch_type import BranchType
+from baobab_ai_dev_git.exceptions.invalid_branch_name_error import InvalidBranchNameError
+from baobab_ai_dev_git.result.branch_validation_result import BranchValidationResult
+
+
+class BranchNameValidator:
+    """Valide un nom de branche à l'aide du parseur métier."""
+
+    def __init__(self, parser: BranchNameParser | None = None) -> None:
+        """Initialise le validateur.
+
+        :param parser: Parseur injecté ; instance par défaut si absent.
+        :type parser: BranchNameParser | None
+        """
+        self._parser: BranchNameParser = parser or BranchNameParser()
+
+    def validate(self, raw_name: str) -> BranchValidationResult:
+        """Valide un nom de branche sans lever d'exception.
+
+        :param raw_name: Nom brut à valider.
+        :type raw_name: str
+        :return: Résultat structuré de validation.
+        :rtype: BranchValidationResult
+        """
+        try:
+            self.validate_or_raise(raw_name)
+        except InvalidBranchNameError as error:
+            return BranchValidationResult(
+                is_valid=False,
+                errors=[str(error)],
+            )
+
+        parsed = self._parser.parse(raw_name)
+        return BranchValidationResult(is_valid=True, branch_name=parsed)
+
+    def validate_or_raise(self, raw_name: str) -> BranchName:
+        """Valide un nom de branche et lève une exception si invalide.
+
+        :param raw_name: Nom brut à valider.
+        :type raw_name: str
+        :return: Nom parsé conforme.
+        :rtype: BranchName
+        :raises InvalidBranchNameError: Si le format est invalide.
+        """
+        if not raw_name or not raw_name.strip():
+            msg = "Le nom de branche ne peut pas être vide."
+            raise InvalidBranchNameError(msg, branch_name=raw_name)
+
+        parsed = self._parser.parse(raw_name.strip())
+
+        if parsed.branch_type == BranchType.UNKNOWN:
+            msg = f"Format de branche non reconnu : '{parsed.raw_name}'."
+            raise InvalidBranchNameError(msg, branch_name=parsed.raw_name)
+
+        if parsed.branch_type != BranchType.MAIN and not parsed.slug:
+            msg = f"Le slug est obligatoire pour la branche '{parsed.raw_name}'."
+            raise InvalidBranchNameError(msg, branch_name=parsed.raw_name)
+
+        if parsed.branch_type == BranchType.USER_STORY and not parsed.user_story_id:
+            msg = f"Identifiant user story manquant pour '{parsed.raw_name}'."
+            raise InvalidBranchNameError(msg, branch_name=parsed.raw_name)
+
+        if parsed.branch_type == BranchType.FEATURE:
+            if not parsed.user_story_id or not parsed.feature_id:
+                msg = f"Identifiants US/FEAT manquants pour '{parsed.raw_name}'."
+                raise InvalidBranchNameError(msg, branch_name=parsed.raw_name)
+
+        if parsed.branch_type == BranchType.BACKLOG:
+            if not parsed.feature_id or not parsed.backlog_id:
+                msg = f"Identifiants FEAT/BL manquants pour '{parsed.raw_name}'."
+                raise InvalidBranchNameError(msg, branch_name=parsed.raw_name)
+
+        return parsed

baobab_ai_dev_git/branch/branch_service.py

@@ -0,0 +1,116 @@
+"""Coordonne la création de branches conformes à la hiérarchie Git."""
+
+from baobab_ai_dev_git.branch.branch_hierarchy_validator import BranchHierarchyValidator
+from baobab_ai_dev_git.branch.branch_name_builder import BranchNameBuilder
+from baobab_ai_dev_git.domain import Backlog, Feature, UserStory
+from baobab_ai_dev_git.repository.git_repository_service import GitRepositoryService
+from baobab_ai_dev_git.result.git_operation_result import GitOperationResult
+
+
+class BranchService:
+    """Orchestre builder, validateur hiérarchique et service Git."""
+
+    def __init__(
+        self,
+        builder: BranchNameBuilder | None = None,
+        hierarchy_validator: BranchHierarchyValidator | None = None,
+        git_repository: GitRepositoryService | None = None,
+    ) -> None:
+        """Initialise le service.
+
+        :param builder: Générateur de noms de branches.
+        :type builder: BranchNameBuilder | None
+        :param hierarchy_validator: Validateur de hiérarchie parent/enfant.
+        :type hierarchy_validator: BranchHierarchyValidator | None
+        :param git_repository: Service Git injecté.
+        :type git_repository: GitRepositoryService | None
+        """
+        self._builder: BranchNameBuilder = builder or BranchNameBuilder()
+        self._hierarchy: BranchHierarchyValidator = (
+            hierarchy_validator or BranchHierarchyValidator()
+        )
+        self._git: GitRepositoryService = git_repository or GitRepositoryService()
+
+    def create_user_story_branch(
+        self,
+        user_story: UserStory,
+        parent_branch: str = "main",
+        cwd: str | None = None,
+    ) -> GitOperationResult:
+        """Crée une branche user story depuis ``main``.
+
+        :param user_story: User story source.
+        :type user_story: UserStory
+        :param parent_branch: Branche parente (``main`` par défaut).
+        :type parent_branch: str
+        :param cwd: Répertoire du dépôt.
+        :type cwd: str | None
+        :return: Résultat de la création Git.
+        :rtype: GitOperationResult
+        """
+        branch_name = self._builder.build_user_story_branch(user_story)
+        return self._create_from_parent(parent_branch, branch_name, cwd=cwd)
+
+    def create_feature_branch(
+        self,
+        feature: Feature,
+        parent_branch: str,
+        cwd: str | None = None,
+    ) -> GitOperationResult:
+        """Crée une branche feature depuis sa user story parente.
+
+        :param feature: Feature source.
+        :type feature: Feature
+        :param parent_branch: Branche user story parente.
+        :type parent_branch: str
+        :param cwd: Répertoire du dépôt.
+        :type cwd: str | None
+        :return: Résultat de la création Git.
+        :rtype: GitOperationResult
+        """
+        branch_name = self._builder.build_feature_branch(feature)
+        return self._create_from_parent(parent_branch, branch_name, cwd=cwd)
+
+    def create_backlog_branch(
+        self,
+        backlog: Backlog,
+        parent_branch: str,
+        cwd: str | None = None,
+    ) -> GitOperationResult:
+        """Crée une branche backlog depuis sa feature parente.
+
+        :param backlog: Backlog source.
+        :type backlog: Backlog
+        :param parent_branch: Branche feature parente.
+        :type parent_branch: str
+        :param cwd: Répertoire du dépôt.
+        :type cwd: str | None
+        :return: Résultat de la création Git.
+        :rtype: GitOperationResult
+        """
+        branch_name = self._builder.build_backlog_branch(backlog)
+        self._hierarchy.validate(parent_branch, branch_name)
+        return self._git.prepare_backlog_branch(branch_name, parent_branch, cwd=cwd)
+
+    def _create_from_parent(
+        self,
+        parent_branch: str,
+        branch_name: str,
+        *,
+        cwd: str | None,
+    ) -> GitOperationResult:
+        """Crée une branche enfant après validation hiérarchique.
+
+        :param parent_branch: Branche parente.
+        :type parent_branch: str
+        :param branch_name: Nom de la branche à créer.
+        :type branch_name: str
+        :param cwd: Répertoire du dépôt.
+        :type cwd: str | None
+        :return: Résultat de création.
+        :rtype: GitOperationResult
+        """
+        self._hierarchy.validate(parent_branch, branch_name)
+        self._git.checkout_branch(parent_branch, cwd=cwd)
+        self._git.ensure_current_branch(parent_branch, cwd=cwd)
+        return self._git.create_branch(branch_name, cwd=cwd)

baobab_ai_dev_git/branch/branch_type.py

@@ -0,0 +1,20 @@
+"""Types de branches Git reconnus par la librairie."""
+
+from enum import Enum
+
+
+class BranchType(Enum):
+    """Énumération des types de branches supportés.
+
+    :cvar MAIN: Branche principale ``main``.
+    :cvar USER_STORY: Branche user story ``us/*``.
+    :cvar FEATURE: Branche feature ``feat/<US-ID>/*``.
+    :cvar BACKLOG: Branche backlog ``bl/<FEAT-ID>/*``.
+    :cvar UNKNOWN: Format non reconnu.
+    """
+
+    MAIN = "MAIN"
+    USER_STORY = "USER_STORY"
+    FEATURE = "FEATURE"
+    BACKLOG = "BACKLOG"
+    UNKNOWN = "UNKNOWN"

baobab_ai_dev_git/domain/__init__.py

@@ -0,0 +1,7 @@
+"""Entités métier officielles réexportées depuis baobab-ai-dev-core."""
+
+from baobab_ai_dev_core.domain.entities.backlog import Backlog
+from baobab_ai_dev_core.domain.entities.feature import Feature
+from baobab_ai_dev_core.domain.entities.user_story import UserStory
+
+__all__ = ["Backlog", "Feature", "UserStory"]

baobab_ai_dev_git/exceptions/__init__.py

@@ -0,0 +1,29 @@
+"""Catalogue public des exceptions métier Git consolidées."""
+
+from baobab_ai_dev_git.exceptions.branch_already_exists_error import BranchAlreadyExistsError
+from baobab_ai_dev_git.exceptions.branch_not_found_error import BranchNotFoundError
+from baobab_ai_dev_git.exceptions.git_operation_error import GitOperationError
+from baobab_ai_dev_git.exceptions.github_integration_error import GithubIntegrationError
+from baobab_ai_dev_git.exceptions.github_operation_error import GithubOperationError
+from baobab_ai_dev_git.exceptions.invalid_branch_hierarchy_error import (
+    InvalidBranchHierarchyError,
+)
+from baobab_ai_dev_git.exceptions.invalid_branch_name_error import InvalidBranchNameError
+from baobab_ai_dev_git.exceptions.invalid_pull_request_target_error import (
+    InvalidPullRequestTargetError,
+)
+from baobab_ai_dev_git.exceptions.merge_not_allowed_error import MergeNotAllowedError
+from baobab_ai_dev_git.exceptions.repository_dirty_error import RepositoryDirtyError
+
+__all__ = [
+    "BranchAlreadyExistsError",
+    "BranchNotFoundError",
+    "GitOperationError",
+    "GithubIntegrationError",
+    "GithubOperationError",
+    "InvalidBranchHierarchyError",
+    "InvalidBranchNameError",
+    "InvalidPullRequestTargetError",
+    "MergeNotAllowedError",
+    "RepositoryDirtyError",
+]

baobab_ai_dev_git/exceptions/branch_already_exists_error.py

@@ -0,0 +1,16 @@
+"""Exception levée lorsqu'une branche existe déjà."""
+
+from baobab_ai_dev_git.exceptions.git_operation_error import GitOperationError
+
+
+class BranchAlreadyExistsError(GitOperationError):
+    """Signale une tentative de création sur une branche existante.
+
+    :param branch_name: Nom de la branche en conflit.
+    :type branch_name: str | None
+    """
+
+    def __init__(self, branch_name: str, message: str | None = None) -> None:
+        self.branch_name: str = branch_name
+        text = message or f"La branche '{branch_name}' existe déjà."
+        super().__init__(text, operation="branch-already-exists")

baobab_ai_dev_git/exceptions/branch_not_found_error.py

@@ -0,0 +1,16 @@
+"""Exception levée lorsqu'une branche attendue est introuvable."""
+
+from baobab_ai_dev_git.exceptions.git_operation_error import GitOperationError
+
+
+class BranchNotFoundError(GitOperationError):
+    """Signale qu'une branche locale recherchée n'existe pas.
+
+    :param branch_name: Nom de la branche introuvable.
+    :type branch_name: str
+    """
+
+    def __init__(self, branch_name: str, message: str | None = None) -> None:
+        self.branch_name: str = branch_name
+        text = message or f"La branche '{branch_name}' est introuvable."
+        super().__init__(text, operation="branch-not-found")