arclith-cli 0.11.0__tar.gz → 0.12.0__tar.gz

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arclith-cli
-Version: 0.11.0
+Version: 0.12.0
 Summary: CLI scaffolding tool for arclith — hexagonal architecture framework
 Author-email: Killian KOPP <killiankopp@gmail.com>
 License:                                  Apache License
@@ -186,7 +186,7 @@ License:                                  Apache License
 License-File: LICENSE
 Keywords: arclith,cli,ddd,hexagonal-architecture,scaffold
 Requires-Python: >=3.13
-Requires-Dist: arclith>=0.14.0
+Requires-Dist: arclith>=0.15.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.15.0

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/README.md

@@ -96,25 +96,27 @@ Comme `add-entity`, cette commande ne câble pas FastAPI, FastMCP, LangGraph, un
 
 ---
 
-### `add-planner` — Ajouter un planner applicatif
+### `add-intent-interpreter` — Ajouter un interpréteur d'intention
 
-Crée uniquement le fichier minimal d'un planner dans `src/<package>/application/planners/`.
+Crée uniquement le fichier minimal d'un interpréteur d'intention dans
+`src/<package>/application/intent_interpreters/`.
 
 ```bash
 cd my-recipe-service
-arclith-cli add-planner IngredientIntent
-arclith-cli add-planner command-router
+arclith-cli add-intent-interpreter IngredientIntent
+arclith-cli add-intent-interpreter command-router
 ```
 
 Fichier généré :
 
 ```text
-src/<package>/application/planners/ingredient_intent.py
+src/<package>/application/intent_interpreters/ingredient_intent.py
 ```
 
-Le planner est le composant applicatif qui transforme une demande naturelle en commande ou DTO
-structuré. Il ne remplace pas LangGraph : LangGraph orchestre les nœuds, tandis que le planner porte
-la traduction d'intention. Le fichier généré reste volontairement vide de logique métier.
+L'interpréteur d'intention est le composant applicatif qui transforme une demande naturelle en
+commande ou DTO structuré. Il ne remplace pas LangGraph : LangGraph orchestre les nœuds, tandis que
+l'interpréteur porte la traduction d'intention. Le fichier généré reste volontairement vide de
+logique métier.
 
 ---
 

arclith_cli-0.12.0/arclith_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.12.0"

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/arclith_cli/capabilities.py

@@ -314,7 +314,7 @@ port: {port}
 LLM_CAPABILITY = CapabilitySpec(
     name="llm",
     layer="outbound",
-    description="Configuration LLM pour planners et agents via une factory Arclith.",
+    description="Configuration LLM pour interpréteurs d'intention et agents via une factory Arclith.",
     activation_config_key=None,
     adapters=(
         AdapterSpec(
@@ -401,7 +401,7 @@ OPENAI_API_KEY={api_key}
             name="anthropic",
             capability="llm",
             layer="outbound",
-            description="Modèle Anthropic pour planners et agents.",
+            description="Modèle Anthropic pour interpréteurs d'intention et agents.",
             config_path="config/adapters/outbound/lm.yaml",
             config_template="""\
 provider: anthropic

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/arclith_cli/core_scaffold.py

@@ -38,9 +38,9 @@ class {class_name}UseCase({class_name}Port):
         raise NotImplementedError("Implement {class_name}UseCase.execute")
 """
 
-_PLANNER_TEMPLATE = """class {class_name}Planner:
-    async def plan(self, prompt: str) -> None:
-        raise NotImplementedError("Implement {class_name}Planner.plan")
+_INTENT_INTERPRETER_TEMPLATE = """class {class_name}Interpreter:
+    async def interpret(self, prompt: str) -> None:
+        raise NotImplementedError("Implement {class_name}Interpreter.interpret")
 """
 
 
@@ -61,17 +61,17 @@ class UseCaseNames:
 
 
 @dataclass(frozen=True)
-class PlannerNames:
+class IntentInterpreterNames:
     pascal: str
     snake: str
 
     @classmethod
-    def from_input(cls, raw: str) -> PlannerNames:
+    def from_input(cls, raw: str) -> IntentInterpreterNames:
         names = EntityNames.from_input(raw)
-        pascal = _strip_pascal_planner_suffix(names.pascal)
-        snake = _strip_snake_planner_suffix(names.snake)
+        pascal = _strip_pascal_intent_interpreter_suffix(names.pascal)
+        snake = _strip_snake_intent_interpreter_suffix(names.snake)
         if not pascal or not snake:
-            console.print(f"[red]✗[/red] Nom de planner invalide : [bold]{raw}[/bold].")
+            console.print(f"[red]✗[/red] Nom d'interpréteur d'intention invalide : [bold]{raw}[/bold].")
             raise typer.Exit(1)
         return cls(pascal=pascal, snake=snake)
 
@@ -130,24 +130,24 @@ def add_usecase_cmd(*, project_dir: Path | None = None, usecase_name: str) -> Pa
     return usecase_file
 
 
-def add_planner_cmd(*, project_dir: Path | None = None, planner_name: str) -> Path:
+def add_intent_interpreter_cmd(*, project_dir: Path | None = None, intent_name: str) -> Path:
     project_dir = project_dir or Path.cwd()
-    planner_name = planner_name.strip()
-    _assert_project_root(project_dir, command="add-planner")
-    _assert_valid_name(planner_name, label="planner")
+    intent_name = intent_name.strip()
+    _assert_project_root(project_dir, command="add-intent-interpreter")
+    _assert_valid_name(intent_name, label="interpréteur d'intention")
 
     paths = detect_project_paths(project_dir)
-    names = PlannerNames.from_input(planner_name)
-    planner_file = paths.application_planners / f"{names.snake}.py"
-    _assert_missing(planner_file, project_dir)
+    names = IntentInterpreterNames.from_input(intent_name)
+    intent_file = paths.application_intent_interpreters / f"{names.snake}.py"
+    _assert_missing(intent_file, project_dir)
 
-    _ensure_package_dirs(paths, "application", "planners")
-    planner_file.write_text(_PLANNER_TEMPLATE.format(class_name=names.pascal), encoding="utf-8")
+    _ensure_package_dirs(paths, "application", "intent_interpreters")
+    intent_file.write_text(_INTENT_INTERPRETER_TEMPLATE.format(class_name=names.pascal), encoding="utf-8")
     console.print(
-        f"[green]✓[/green] Planner {names.pascal}Planner créé : "
-        f"[bold]{planner_file.relative_to(project_dir)}[/bold]"
+        f"[green]✓[/green] Interpréteur d'intention {names.pascal}Interpreter créé : "
+        f"[bold]{intent_file.relative_to(project_dir)}[/bold]"
     )
-    return planner_file
+    return intent_file
 
 
 def _assert_project_root(project_dir: Path, *, command: str) -> None:
@@ -232,8 +232,8 @@ def _strip_snake_suffix(value: str) -> str:
         value = stripped
 
 
-def _strip_pascal_planner_suffix(value: str) -> str:
-    suffixes = ("Planner",)
+def _strip_pascal_intent_interpreter_suffix(value: str) -> str:
+    suffixes = ("Interpreter",)
     while True:
         stripped = value
         for suffix in suffixes:
@@ -245,8 +245,8 @@ def _strip_pascal_planner_suffix(value: str) -> str:
         value = stripped
 
 
-def _strip_snake_planner_suffix(value: str) -> str:
-    suffixes = ("_planner",)
+def _strip_snake_intent_interpreter_suffix(value: str) -> str:
+    suffixes = ("_interpreter",)
     while True:
         stripped = value
         for suffix in suffixes:

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/arclith_cli/init_project.py

@@ -72,7 +72,7 @@ def _framework_version() -> str:
     try:
         return version("arclith")
     except PackageNotFoundError:
-        return "0.14.0"
+        return "0.15.0"
 
 
 def _create_package_layout(package_root: Path) -> None:
@@ -85,7 +85,7 @@ def _create_package_layout(package_root: Path) -> None:
         package_root / "domain" / "ports" / "outbound",
         package_root / "application",
         package_root / "application" / "use_cases",
-        package_root / "application" / "planners",
+        package_root / "application" / "intent_interpreters",
         package_root / "adapters",
         package_root / "adapters" / "inbound",
         package_root / "adapters" / "outbound",

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/arclith_cli/main.py

@@ -15,7 +15,7 @@ from rich.tree import Tree
 from . import __version__
 from .add_adapter import add_adapter_cmd
 from .capabilities import CAPABILITY_CATALOG, capability_catalog_as_dict
-from .core_scaffold import add_entity_cmd, add_planner_cmd, add_usecase_cmd
+from .core_scaffold import add_entity_cmd, add_intent_interpreter_cmd, add_usecase_cmd
 from .export_config import export_config_cmd
 from .init_project import init_project_cmd
 from .rename import EntityNames, apply_rename
@@ -221,17 +221,17 @@ def add_usecase(
     add_usecase_cmd(usecase_name=usecase or _prompt_usecase())
 
 
-@app.command(name="add-planner")
-def add_planner(
-    planner: Annotated[
+@app.command(name="add-intent-interpreter")
+def add_intent_interpreter(
+    intent: Annotated[
         str | None,
         typer.Argument(
-            help="Nom du planner applicatif. Exemple : IngredientIntent, todo_planner, command-router",
+            help="Nom de l'interpréteur d'intention. Exemple : IngredientIntent, todo-intent, command-router",
         ),
     ] = None,
 ) -> None:
-    """Créer uniquement le fichier minimal d'un planner dans application/planners."""
-    add_planner_cmd(planner_name=planner or _prompt_planner())
+    """Créer uniquement le fichier minimal d'un interpréteur d'intention."""
+    add_intent_interpreter_cmd(intent_name=intent or _prompt_intent_interpreter())
 
 
 @app.command(name="capabilities")
@@ -327,10 +327,10 @@ def _prompt_usecase() -> str:
             return value
 
 
-def _prompt_planner() -> str:
-    console.print("\n[bold]Planner[/bold] [dim](ex : IngredientIntent, todo_planner)[/dim]")
+def _prompt_intent_interpreter() -> str:
+    console.print("\n[bold]Interpréteur d'intention[/bold] [dim](ex : IngredientIntent, todo_intent)[/dim]")
     while True:
-        value = Prompt.ask("  [bold green]Nom du planner[/bold green]").strip()
+        value = Prompt.ask("  [bold green]Nom de l'interpréteur[/bold green]").strip()
         if not value:
             console.print("  [red]Le nom ne peut pas être vide.[/red]")
         elif not _ENTITY_RE.match(value):

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/arclith_cli/project_paths.py

@@ -21,8 +21,8 @@ class ProjectPaths:
         return self.package_root / "domain" / "ports" / "inbound"
 
     @property
-    def application_planners(self) -> Path:
-        return self.package_root / "application" / "planners"
+    def application_intent_interpreters(self) -> Path:
+        return self.package_root / "application" / "intent_interpreters"
 
     @property
     def adapters_outbound(self) -> Path:

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arclith-cli"
-version = "0.11.0"
+version = "0.12.0"
 description = "CLI scaffolding tool for arclith — hexagonal architecture framework"
 license = { file = "LICENSE" }
 requires-python = ">=3.13"
@@ -16,7 +16,7 @@ dependencies = [
     "typer>=0.15.0",
     "rich>=13.0.0",
     "httpx>=0.27.0",
-    "arclith>=0.14.0",
+    "arclith>=0.15.0",
 ]
 
 [tool.uv.sources]

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/tests/e2e_manual.sh

@@ -39,7 +39,7 @@ if grep -q '\[tool\.uv\.sources\]' pyproject.toml; then
 fi
 
 ARCLITH_VERSION=$(grep 'arclith\[' pyproject.toml | grep -oE '[0-9]+\.[0-9]+\.[0-9]+')
-MIN_ARCLITH_VERSION="0.13.0"
+MIN_ARCLITH_VERSION="0.15.0"
 if version_lt "$ARCLITH_VERSION" "$MIN_ARCLITH_VERSION"; then
     echo -e "${RED}✗ FAIL: arclith version < $MIN_ARCLITH_VERSION (found: $ARCLITH_VERSION)${NC}"
     exit 1

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/tests/test_core_scaffold.py

@@ -3,7 +3,7 @@ from pathlib import Path
 import pytest
 import typer
 
-from arclith_cli.core_scaffold import add_entity_cmd, add_planner_cmd, add_usecase_cmd
+from arclith_cli.core_scaffold import add_entity_cmd, add_intent_interpreter_cmd, add_usecase_cmd
 from arclith_cli.init_project import init_project_cmd
 
 
@@ -47,7 +47,7 @@ def test_init_project_creates_minimal_src_layout_without_entity(tmp_path: Path)
         "observability:\n"
         "  enabled: []\n"
     )
-    assert "arclith[fastapi,mcp]>=0.14.0" in (generated / "pyproject.toml").read_text(encoding="utf-8")
+    assert "arclith[fastapi,mcp]>=0.15.0" in (generated / "pyproject.toml").read_text(encoding="utf-8")
     assert (package_root / "domain" / "models" / "__init__.py").exists()
     assert (package_root / "domain" / "ports" / "inbound" / "__init__.py").exists()
     assert (package_root / "domain" / "ports" / "outbound" / "__init__.py").exists()
@@ -97,19 +97,23 @@ def test_add_usecase_creates_minimal_usecase_in_src_package(tmp_path: Path) -> N
     assert not (project_dir / "src" / "demo_service" / "adapters").exists()
 
 
-def test_add_planner_creates_minimal_planner_in_src_package(tmp_path: Path) -> None:
+def test_add_intent_interpreter_creates_minimal_interpreter_in_src_package(tmp_path: Path) -> None:
     project_dir = _src_project(tmp_path)
 
-    generated = add_planner_cmd(project_dir=project_dir, planner_name="IngredientIntent")
+    generated = add_intent_interpreter_cmd(project_dir=project_dir, intent_name="IngredientIntent")
 
-    assert generated == project_dir / "src" / "demo_service" / "application" / "planners" / "ingredient_intent.py"
+    assert generated == (
+        project_dir / "src" / "demo_service" / "application" / "intent_interpreters" / "ingredient_intent.py"
+    )
     assert generated.read_text(encoding="utf-8") == (
-        "class IngredientIntentPlanner:\n"
-        "    async def plan(self, prompt: str) -> None:\n"
-        '        raise NotImplementedError("Implement IngredientIntentPlanner.plan")\n'
+        "class IngredientIntentInterpreter:\n"
+        "    async def interpret(self, prompt: str) -> None:\n"
+        '        raise NotImplementedError("Implement IngredientIntentInterpreter.interpret")\n'
     )
     assert (project_dir / "src" / "demo_service" / "application" / "__init__.py").exists()
-    assert (project_dir / "src" / "demo_service" / "application" / "planners" / "__init__.py").exists()
+    assert (
+        project_dir / "src" / "demo_service" / "application" / "intent_interpreters" / "__init__.py"
+    ).exists()
     assert not (project_dir / "src" / "demo_service" / "adapters").exists()
 
 
@@ -129,14 +133,17 @@ def test_add_usecase_strips_repeated_usecase_suffix(tmp_path: Path) -> None:
     assert "UseCaseUseCase" not in generated.read_text(encoding="utf-8")
 
 
-def test_add_planner_strips_repeated_planner_suffix(tmp_path: Path) -> None:
+def test_add_intent_interpreter_strips_repeated_interpreter_suffix(tmp_path: Path) -> None:
     project_dir = _src_project(tmp_path)
 
-    generated = add_planner_cmd(project_dir=project_dir, planner_name="ingredient-intent-planner-planner")
+    generated = add_intent_interpreter_cmd(
+        project_dir=project_dir,
+        intent_name="ingredient-intent-interpreter-interpreter",
+    )
 
     assert generated.name == "ingredient_intent.py"
-    assert "class IngredientIntentPlanner:" in generated.read_text(encoding="utf-8")
-    assert "PlannerPlanner" not in generated.read_text(encoding="utf-8")
+    assert "class IngredientIntentInterpreter:" in generated.read_text(encoding="utf-8")
+    assert "InterpreterInterpreter" not in generated.read_text(encoding="utf-8")
 
 
 def test_add_entity_supports_legacy_root_layout(tmp_path: Path) -> None:
@@ -201,8 +208,8 @@ def test_add_usecase_refuses_to_overwrite_existing_inbound_port(tmp_path: Path)
     assert not (project_dir / "src" / "demo_service" / "application" / "use_cases" / "recipe.py").exists()
 
 
-def test_add_planner_rejects_invalid_name(tmp_path: Path) -> None:
+def test_add_intent_interpreter_rejects_invalid_name(tmp_path: Path) -> None:
     project_dir = _src_project(tmp_path)
 
     with pytest.raises(typer.Exit):
-        add_planner_cmd(project_dir=project_dir, planner_name="123-planner")
+        add_intent_interpreter_cmd(project_dir=project_dir, intent_name="123-intent")

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/tests/test_e2e_scaffold.py

@@ -225,7 +225,7 @@ def test_scaffold_and_run(temp_workspace: Path):
     result = subprocess.run(
         [
             "arclith-cli",
-            "add-planner",
+            "add-intent-interpreter",
             "ShoppingIntent",
         ],
         cwd=project_dir,
@@ -233,9 +233,11 @@ def test_scaffold_and_run(temp_workspace: Path):
         text=True,
         timeout=30,
     )
-    assert result.returncode == 0, f"add-planner failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+    assert result.returncode == 0, (
+        f"add-intent-interpreter failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+    )
     assert (
-        project_dir / "src" / "test_plan_service" / "application" / "planners" / "shopping_intent.py"
+        project_dir / "src" / "test_plan_service" / "application" / "intent_interpreters" / "shopping_intent.py"
     ).exists()
 
     printed_names = ", ".join(
@@ -243,7 +245,7 @@ def test_scaffold_and_run(temp_workspace: Path):
             "ShoppingItem.__name__",
             "PlanShoppingListPort.__name__",
             "PlanShoppingListUseCase.__name__",
-            "ShoppingIntentPlanner.__name__",
+            "ShoppingIntentInterpreter.__name__",
         ]
     )
     import_script = "\n".join(
@@ -251,7 +253,7 @@ def test_scaffold_and_run(temp_workspace: Path):
             "from test_plan_service.domain.models.shopping_item import ShoppingItem",
             "from test_plan_service.domain.ports.inbound.plan_shopping_list import PlanShoppingListPort",
             "from test_plan_service.application.use_cases.plan_shopping_list import PlanShoppingListUseCase",
-            "from test_plan_service.application.planners.shopping_intent import ShoppingIntentPlanner",
+            "from test_plan_service.application.intent_interpreters.shopping_intent import ShoppingIntentInterpreter",
             f"print({printed_names})",
         ]
     )
@@ -269,7 +271,7 @@ def test_scaffold_and_run(temp_workspace: Path):
         timeout=30,
     )
     assert result.returncode == 0, f"Core scaffold import failed:\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
-    assert "ShoppingItem PlanShoppingListPort PlanShoppingListUseCase ShoppingIntentPlanner" in result.stdout
+    assert "ShoppingItem PlanShoppingListPort PlanShoppingListUseCase ShoppingIntentInterpreter" in result.stdout
 
     # Step 7 — validate non-interactive adapter generation through the CLI entry point
     result = subprocess.run(

{arclith_cli-0.11.0 → arclith_cli-0.12.0}/uv.lock

@@ -46,7 +46,7 @@ wheels = [
 
 [[package]]
 name = "arclith"
-version = "0.14.0"
+version = "0.15.0"
 source = { editable = "../" }
 dependencies = [
     { name = "fastapi" },
@@ -132,7 +132,7 @@ docs = [
 
 [[package]]
 name = "arclith-cli"
-version = "0.11.0"
+version = "0.12.0"
 source = { editable = "." }
 dependencies = [
     { name = "arclith" },

arclith_cli-0.11.0/arclith_cli/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.11.0"