baobab-ai-dev-core 1.0.0__tar.gz

baobab_ai_dev_core-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 baobabgit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

baobab_ai_dev_core-1.0.0/PKG-INFO

@@ -0,0 +1,152 @@
+Metadata-Version: 2.4
+Name: baobab-ai-dev-core
+Version: 1.0.0
+Summary: Noyau métier Python pur de l'écosystème baobab-ai-development : entités, objets de valeur, enums, exceptions, politiques et contrats partagés.
+Author-email: Michel ANDRIANAIVO <patrick.andri@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/baobabgit/baobab-ai-dev-core
+Project-URL: Repository, https://github.com/baobabgit/baobab-ai-dev-core.git
+Keywords: baobab,domain,core,workflow,ai-development
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# baobab-ai-dev-core
+
+Noyau métier Python pur de l'écosystème **baobab-ai-development**.
+
+Ce module centralise le vocabulaire et les règles métier partagés par les modules
+d'infrastructure : `database`, `documents`, `git`, `quality`, `providers`, `workflow`,
+`API`, `CLI` et `workers`. Il ne réalise aucune I/O (réseau, disque, base de données) :
+il modélise le domaine, valide les invariants et publie des contrats (`Protocol`) que
+les adaptateurs externes implémentent.
+
+## Rôle du module
+
+`baobab-ai-dev-core` fournit :
+
+- **Entités** — `Project`, `UserStory`, `Feature`, `Backlog`, `WorkflowRun`,
+  `WorkflowStep`, `Job`, `AiProvider`, `Blocker`, `Artifact`, `QualityCheck`,
+  `PullRequest`
+- **Objets de valeur** — identifiants, codes métier (`US-XXX`, `FEAT-XXX`, `BL-XXX`),
+  noms de branches, titres, versions sémantiques
+- **Enums** — statuts, types, sévérités et décisions stables du domaine
+- **Exceptions** — hiérarchie `BaobabAiDevCoreError` avec messages exploitables
+- **Politiques** — règles pures sans I/O (transitions, hiérarchie, branches, merge,
+  quality gate, fallback provider)
+- **Contrats `Protocol`** — repositories et clients Git, PR, qualité, providers IA,
+  horloge injectable
+
+Le workflow documentaire **US → FEAT → BL** et la hiérarchie Git **`main` → `us/*` →
+`feat/*` → `bl/*`** sont modélisés et validables dans ce noyau.
+
+## Non-objectifs
+
+Ce package **n'implémente pas** :
+
+- API HTTP (FastAPI, etc.)
+- Persistance SQL (SQLAlchemy, Alembic)
+- Appels Git ou GitHub réels
+- Exécution de providers IA (Cursor, Claude, GPT, Codex, etc.)
+- Runners qualité réels, parsing Markdown, file de jobs persistée, CLI
+
+Ces responsabilités appartiennent aux modules consommateurs qui implémentent les
+`Protocol` du domaine.
+
+## Prérequis
+
+- Python **>= 3.12**
+- Dépendances runtime : **aucune** (bibliothèque standard uniquement)
+
+## Installation locale (développement)
+
+Depuis la racine du dépôt :
+
+```bash
+python -m pip install -e .
+```
+
+Vérifier que le package est importable :
+
+```bash
+python -c "import baobab_ai_dev_core; print(baobab_ai_dev_core.__version__)"
+```
+
+## Premiers imports
+
+### API publique stabilisée
+
+Les consommateurs doivent importer depuis le package racine. Seuls les symboles listés
+dans `__all__` constituent le contrat public stable :
+
+```python
+import baobab_ai_dev_core
+
+print(baobab_ai_dev_core.__version__)  # "1.0.0"
+print(baobab_ai_dev_core.__all__)        # ["__version__"]
+```
+
+```python
+from baobab_ai_dev_core import __version__
+
+assert __version__ == "1.0.0"
+```
+
+Tout symbole absent de `__all__` est considéré **interne** et peut évoluer sans
+préavis. Les ré-exportations publiques des briques domaine seront étendues au fur et à
+mesure de leur stabilisation.
+
+### Accès aux briques domaine (usage interne écosystème)
+
+En attendant l'élargissement de `__all__`, les modules de l'écosystème importent les
+sous-packages du domaine avec des **imports absolus** :
+
+```python
+from baobab_ai_dev_core.domain.entities.project import Project
+from baobab_ai_dev_core.domain.value_objects.entity_id import EntityId
+from baobab_ai_dev_core.domain.value_objects.project_slug import ProjectSlug
+from baobab_ai_dev_core.domain.enums.project_status import ProjectStatus
+from baobab_ai_dev_core.domain.policies.branch_policy import BranchPolicy
+from baobab_ai_dev_core.domain.protocols.git_client_protocol import GitClientProtocol
+```
+
+Ne pas importer depuis des chemins relatifs ; ne pas dépendre de symboles non exportés
+via `__all__` pour une API tierce.
+
+## Arborescence du domaine
+
+```text
+src/baobab_ai_dev_core/domain/
+  entities/       # entités avec identité et transitions explicites
+  value_objects/  # objets immuables validés à la création
+  enums/          # vocabulaires stables
+  exceptions/     # erreurs métier
+  policies/       # règles pures sans I/O
+  protocols/      # contrats pour l'infrastructure
+```
+
+Les tests unitaires miroirs vivent sous `tests/baobab_ai_dev_core/domain/`.
+
+## Commandes qualité
+
+```bash
+python -m pytest
+python -m ruff check .
+python -m mypy src
+```
+
+## Licence
+
+MIT — voir [LICENSE](LICENSE).

baobab_ai_dev_core-1.0.0/README.md

@@ -0,0 +1,127 @@
+# baobab-ai-dev-core
+
+Noyau métier Python pur de l'écosystème **baobab-ai-development**.
+
+Ce module centralise le vocabulaire et les règles métier partagés par les modules
+d'infrastructure : `database`, `documents`, `git`, `quality`, `providers`, `workflow`,
+`API`, `CLI` et `workers`. Il ne réalise aucune I/O (réseau, disque, base de données) :
+il modélise le domaine, valide les invariants et publie des contrats (`Protocol`) que
+les adaptateurs externes implémentent.
+
+## Rôle du module
+
+`baobab-ai-dev-core` fournit :
+
+- **Entités** — `Project`, `UserStory`, `Feature`, `Backlog`, `WorkflowRun`,
+  `WorkflowStep`, `Job`, `AiProvider`, `Blocker`, `Artifact`, `QualityCheck`,
+  `PullRequest`
+- **Objets de valeur** — identifiants, codes métier (`US-XXX`, `FEAT-XXX`, `BL-XXX`),
+  noms de branches, titres, versions sémantiques
+- **Enums** — statuts, types, sévérités et décisions stables du domaine
+- **Exceptions** — hiérarchie `BaobabAiDevCoreError` avec messages exploitables
+- **Politiques** — règles pures sans I/O (transitions, hiérarchie, branches, merge,
+  quality gate, fallback provider)
+- **Contrats `Protocol`** — repositories et clients Git, PR, qualité, providers IA,
+  horloge injectable
+
+Le workflow documentaire **US → FEAT → BL** et la hiérarchie Git **`main` → `us/*` →
+`feat/*` → `bl/*`** sont modélisés et validables dans ce noyau.
+
+## Non-objectifs
+
+Ce package **n'implémente pas** :
+
+- API HTTP (FastAPI, etc.)
+- Persistance SQL (SQLAlchemy, Alembic)
+- Appels Git ou GitHub réels
+- Exécution de providers IA (Cursor, Claude, GPT, Codex, etc.)
+- Runners qualité réels, parsing Markdown, file de jobs persistée, CLI
+
+Ces responsabilités appartiennent aux modules consommateurs qui implémentent les
+`Protocol` du domaine.
+
+## Prérequis
+
+- Python **>= 3.12**
+- Dépendances runtime : **aucune** (bibliothèque standard uniquement)
+
+## Installation locale (développement)
+
+Depuis la racine du dépôt :
+
+```bash
+python -m pip install -e .
+```
+
+Vérifier que le package est importable :
+
+```bash
+python -c "import baobab_ai_dev_core; print(baobab_ai_dev_core.__version__)"
+```
+
+## Premiers imports
+
+### API publique stabilisée
+
+Les consommateurs doivent importer depuis le package racine. Seuls les symboles listés
+dans `__all__` constituent le contrat public stable :
+
+```python
+import baobab_ai_dev_core
+
+print(baobab_ai_dev_core.__version__)  # "1.0.0"
+print(baobab_ai_dev_core.__all__)        # ["__version__"]
+```
+
+```python
+from baobab_ai_dev_core import __version__
+
+assert __version__ == "1.0.0"
+```
+
+Tout symbole absent de `__all__` est considéré **interne** et peut évoluer sans
+préavis. Les ré-exportations publiques des briques domaine seront étendues au fur et à
+mesure de leur stabilisation.
+
+### Accès aux briques domaine (usage interne écosystème)
+
+En attendant l'élargissement de `__all__`, les modules de l'écosystème importent les
+sous-packages du domaine avec des **imports absolus** :
+
+```python
+from baobab_ai_dev_core.domain.entities.project import Project
+from baobab_ai_dev_core.domain.value_objects.entity_id import EntityId
+from baobab_ai_dev_core.domain.value_objects.project_slug import ProjectSlug
+from baobab_ai_dev_core.domain.enums.project_status import ProjectStatus
+from baobab_ai_dev_core.domain.policies.branch_policy import BranchPolicy
+from baobab_ai_dev_core.domain.protocols.git_client_protocol import GitClientProtocol
+```
+
+Ne pas importer depuis des chemins relatifs ; ne pas dépendre de symboles non exportés
+via `__all__` pour une API tierce.
+
+## Arborescence du domaine
+
+```text
+src/baobab_ai_dev_core/domain/
+  entities/       # entités avec identité et transitions explicites
+  value_objects/  # objets immuables validés à la création
+  enums/          # vocabulaires stables
+  exceptions/     # erreurs métier
+  policies/       # règles pures sans I/O
+  protocols/      # contrats pour l'infrastructure
+```
+
+Les tests unitaires miroirs vivent sous `tests/baobab_ai_dev_core/domain/`.
+
+## Commandes qualité
+
+```bash
+python -m pytest
+python -m ruff check .
+python -m mypy src
+```
+
+## Licence
+
+MIT — voir [LICENSE](LICENSE).

baobab_ai_dev_core-1.0.0/pyproject.toml

@@ -0,0 +1,92 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "baobab-ai-dev-core"
+version = "1.0.0"
+description = "Noyau métier Python pur de l'écosystème baobab-ai-development : entités, objets de valeur, enums, exceptions, politiques et contrats partagés."
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Michel ANDRIANAIVO", email = "patrick.andri@gmail.com" }]
+keywords = ["baobab", "domain", "core", "workflow", "ai-development"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/baobabgit/baobab-ai-dev-core"
+Repository = "https://github.com/baobabgit/baobab-ai-dev-core.git"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+baobab_ai_dev_core = ["py.typed"]
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-ra --strict-markers --strict-config"
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = [
+    "E",    # pycodestyle errors
+    "W",    # pycodestyle warnings
+    "F",    # pyflakes
+    "I",    # isort
+    "N",    # pep8-naming
+    "UP",   # pyupgrade
+    "B",    # flake8-bugbear
+    "C4",   # flake8-comprehensions
+    "SIM",  # flake8-simplify
+    "PT",   # flake8-pytest-style
+    "TID",  # flake8-tidy-imports
+    "ANN",  # flake8-annotations
+    "D",    # pydocstyle
+    "PL",   # pylint
+    "RUF",  # ruff-specific
+]
+ignore = [
+    # D401 impose le « mode impératif » selon une heuristique anglophone,
+    # incompatible avec la convention de docstrings en français du projet.
+    "D401",
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "pep257"
+
+[tool.ruff.lint.flake8-tidy-imports]
+ban-relative-imports = "all"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = ["D101", "D102", "D103", "PLR2004"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+warn_unused_configs = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+disallow_any_generics = true
+no_implicit_reexport = true
+show_error_codes = true

baobab_ai_dev_core-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

baobab_ai_dev_core-1.0.0/src/baobab_ai_dev_core/__init__.py

@@ -0,0 +1,27 @@
+"""baobab-ai-dev-core — noyau métier Python pur de l'écosystème baobab-ai-development.
+
+Ce package expose les briques de domaine (entités, objets de valeur, enums,
+exceptions, politiques et contrats ``Protocol``) consommées par les modules
+database, documents, git, quality, providers, workflow, API, CLI et workers.
+
+Convention d'API publique
+--------------------------
+- Point d'entrée unique : les consommateurs importent depuis ``baobab_ai_dev_core``
+  (``from baobab_ai_dev_core import ...``), jamais depuis les sous-modules internes.
+- Contrat explicite : seuls les symboles listés dans :data:`__all__` font partie de
+  l'API publique stable. Tout symbole absent de ``__all__`` est considéré interne et
+  peut changer sans préavis.
+- Compatibilité : ``__all__`` est maintenu trié pour limiter les diffs et garantir un
+  ordre déterministe. Les sous-packages du domaine (``domain.entities``,
+  ``domain.enums``, ``domain.value_objects``, ``domain.policies``,
+  ``domain.protocols``, ``domain.exceptions``) y seront re-exportés au fur et à mesure
+  de leur stabilisation dans les user stories suivantes.
+
+À ce stade, seul le numéro de version est exposé publiquement via ``__all__``.
+"""
+
+__version__ = "1.0.0"
+
+__all__ = [
+    "__version__",
+]

baobab_ai_dev_core-1.0.0/src/baobab_ai_dev_core/domain/__init__.py

@@ -0,0 +1,5 @@
+"""Sous-package domaine de baobab-ai-dev-core.
+
+Regroupe les briques métier pures : ``entities``, ``value_objects``, ``enums``,
+``exceptions``, ``policies`` et ``protocols``.
+"""

baobab_ai_dev_core-1.0.0/src/baobab_ai_dev_core/domain/entities/__init__.py

@@ -0,0 +1,13 @@
+"""Entités métier du domaine 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.project import Project
+from baobab_ai_dev_core.domain.entities.user_story import UserStory
+
+__all__ = [
+    "Backlog",
+    "Feature",
+    "Project",
+    "UserStory",
+]

baobab_ai_dev_core-1.0.0/src/baobab_ai_dev_core/domain/entities/ai_provider.py

@@ -0,0 +1,134 @@
+"""Entité métier représentant un provider IA au niveau domaine."""
+
+from baobab_ai_dev_core.domain.enums.ai_provider_status import AiProviderStatus
+from baobab_ai_dev_core.domain.enums.ai_provider_type import AiProviderType
+from baobab_ai_dev_core.domain.exceptions.domain_validation_error import (
+    DomainValidationError,
+)
+from baobab_ai_dev_core.domain.value_objects.domain_title import DomainTitle
+from baobab_ai_dev_core.domain.value_objects.entity_id import EntityId
+
+_PRIORITE_MIN = 1
+_QUOTA_OK = "ok"
+_QUOTA_EXHAUSTED = "usage_exhausted"
+
+
+def _valider_priorite(priorite: int) -> int:
+    if priorite < _PRIORITE_MIN:
+        raise DomainValidationError(
+            f"La priorité doit être >= {_PRIORITE_MIN} (reçue : {priorite})."
+        )
+    return priorite
+
+
+def _valider_quota_state(quota_state: str) -> str:
+    nettoye = quota_state.strip()
+    if nettoye not in {_QUOTA_OK, _QUOTA_EXHAUSTED}:
+        raise DomainValidationError(
+            f"quota_state invalide : '{quota_state}'. "
+            f"Valeurs attendues : '{_QUOTA_OK}', '{_QUOTA_EXHAUSTED}'."
+        )
+    return nettoye
+
+
+def _valider_coherence_statut_quota(
+    status: AiProviderStatus,
+    quota_state: str,
+) -> None:
+    """Vérifie l'alignement entre statut et quota."""
+    if status is AiProviderStatus.USAGE_EXHAUSTED and quota_state != _QUOTA_EXHAUSTED:
+        raise DomainValidationError(
+            "Le statut 'usage_exhausted' exige quota_state='usage_exhausted'."
+        )
+    if status is AiProviderStatus.AVAILABLE and quota_state != _QUOTA_OK:
+        raise DomainValidationError(
+            "Le statut 'available' exige quota_state='ok'."
+        )
+
+
+class AiProvider:
+    """Provider IA métier avec priorité, statut et état de quota.
+
+    Ne contient aucun client technique : l'intégration relève du module
+    ``providers``.
+    """
+
+    def __init__(  # noqa: PLR0913
+        self,
+        provider_id: EntityId,
+        name: DomainTitle,
+        provider_type: AiProviderType,
+        status: AiProviderStatus,
+        priority: int,
+        quota_state: str,
+    ) -> None:
+        """Construit un provider en validant priorité et quota."""
+        priorite = _valider_priorite(priority)
+        quota = _valider_quota_state(quota_state)
+        _valider_coherence_statut_quota(status, quota)
+        self._provider_id = provider_id
+        self._name = name
+        self._provider_type = provider_type
+        self._status = status
+        self._priority = priorite
+        self._quota_state = quota
+
+    @property
+    def provider_id(self) -> EntityId:
+        """Identifiant stable du provider."""
+        return self._provider_id
+
+    @property
+    def name(self) -> DomainTitle:
+        """Nom affiché du provider."""
+        return self._name
+
+    @property
+    def provider_type(self) -> AiProviderType:
+        """Famille technique du provider."""
+        return self._provider_type
+
+    @property
+    def status(self) -> AiProviderStatus:
+        """Statut de disponibilité courant."""
+        return self._status
+
+    @property
+    def priority(self) -> int:
+        """Priorité de sélection (1 = la plus haute)."""
+        return self._priority
+
+    @property
+    def quota_state(self) -> str:
+        """État du quota (``ok`` ou ``usage_exhausted``)."""
+        return self._quota_state
+
+    @property
+    def is_selectable(self) -> bool:
+        """Indique si le provider peut être sélectionné pour un run."""
+        return (
+            self._status is AiProviderStatus.AVAILABLE
+            and self._quota_state == _QUOTA_OK
+        )
+
+    def mark_usage_exhausted(self) -> None:
+        """Marque le quota comme épuisé (distinct de indisponible ou erreur)."""
+        self._status = AiProviderStatus.USAGE_EXHAUSTED
+        self._quota_state = _QUOTA_EXHAUSTED
+
+    def mark_error(self) -> None:
+        """Marque une erreur technique sans confondre avec quota épuisé."""
+        self._status = AiProviderStatus.ERROR
+
+    def disable(self) -> None:
+        """Désactive volontairement le provider."""
+        self._status = AiProviderStatus.DISABLED
+
+    def mark_unavailable(self) -> None:
+        """Marque une indisponibilité ponctuelle."""
+        self._status = AiProviderStatus.UNAVAILABLE
+
+    def restore_available(self) -> None:
+        """Restaure un provider disponible avec quota OK."""
+        self._status = AiProviderStatus.AVAILABLE
+        self._quota_state = _QUOTA_OK

baobab_ai_dev_core-1.0.0/src/baobab_ai_dev_core/domain/entities/artifact.py

@@ -0,0 +1,91 @@
+"""Entité métier représentant un livrable produit pendant une exécution."""
+
+import re
+from datetime import datetime
+
+from baobab_ai_dev_core.domain.enums.artifact_type import ArtifactType
+from baobab_ai_dev_core.domain.exceptions.domain_validation_error import (
+    DomainValidationError,
+)
+from baobab_ai_dev_core.domain.value_objects.entity_id import EntityId
+
+_CHEMIN_RELATIF_PATTERN = re.compile(r"^[a-zA-Z0-9_./-]+$")
+
+
+def _valider_chemin(path: str) -> str:
+    nettoye = path.strip()
+    if not nettoye:
+        raise DomainValidationError("Le chemin d'artefact ne peut pas être vide.")
+    if nettoye.startswith("/") or ".." in nettoye.split("/"):
+        raise DomainValidationError(
+            f"Le chemin '{nettoye}' doit être relatif et ne pas contenir '..'."
+        )
+    if not _CHEMIN_RELATIF_PATTERN.fullmatch(nettoye):
+        raise DomainValidationError(
+            f"Le chemin '{nettoye}' contient des caractères non autorisés."
+        )
+    return nettoye
+
+
+def _valider_checksum(checksum: str | None) -> str | None:
+    if checksum is None:
+        return None
+    nettoye = checksum.strip()
+    if not nettoye:
+        raise DomainValidationError(
+            "Le checksum ne peut pas être vide lorsqu'il est renseigné."
+        )
+    return nettoye
+
+
+class Artifact:
+    """Livrable généré pendant un workflow run (patch, rapport, fichier, etc.)."""
+
+    def __init__(  # noqa: PLR0913
+        self,
+        artifact_id: EntityId,
+        workflow_run_id: EntityId,
+        artifact_type: ArtifactType,
+        path: str,
+        checksum: str | None,
+        created_at: datetime,
+    ) -> None:
+        """Construit un artefact en validant le chemin relatif et le checksum."""
+        chemin = _valider_chemin(path)
+        empreinte = _valider_checksum(checksum)
+        self._artifact_id = artifact_id
+        self._workflow_run_id = workflow_run_id
+        self._artifact_type = artifact_type
+        self._path = chemin
+        self._checksum = empreinte
+        self._created_at = created_at
+
+    @property
+    def artifact_id(self) -> EntityId:
+        """Identifiant stable de l'artefact."""
+        return self._artifact_id
+
+    @property
+    def workflow_run_id(self) -> EntityId:
+        """Identifiant du run ayant produit l'artefact."""
+        return self._workflow_run_id
+
+    @property
+    def artifact_type(self) -> ArtifactType:
+        """Type métier de l'artefact."""
+        return self._artifact_type
+
+    @property
+    def path(self) -> str:
+        """Chemin relatif validé de l'artefact."""
+        return self._path
+
+    @property
+    def checksum(self) -> str | None:
+        """Empreinte facultative du contenu."""
+        return self._checksum
+
+    @property
+    def created_at(self) -> datetime:
+        """Horodatage de création."""
+        return self._created_at