arclith-cli 0.7.1__py3-none-any.whl

arclith_cli/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.7.1"
+

arclith_cli/adapter_templates.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from typing import Any
+
+# ── Supported adapters ────────────────────────────────────────────────────────
+
+SUPPORTED_ADAPTERS = ["memory", "mongodb", "duckdb"]
+
+# ── Config YAML templates (scoped — no root key) ──────────────────────────────
+
+CONFIG_YAML: dict[str, str] = {
+    "memory": "",  # memory needs no config file
+    "mongodb": """\
+multitenant: false   # true = URI + db_name résolus par requête via JWT → Vault
+db_name: {db_name}   # uri → secrets.yaml ou Vault (fallback single-tenant)
+""",
+    "duckdb": """\
+multitenant: false
+path: {path}
+""",
+}
+
+# ── Python repository subclass templates ─────────────────────────────────────
+
+REPO_PYTHON: dict[str, str] = {
+    "memory": """\
+from arclith.adapters.output.memory.repository import InMemoryRepository
+from domain.models.{snake} import {pascal}
+from domain.ports.output.{snake}_repository import {pascal}Repository
+
+
+class InMemory{pascal}Repository(InMemoryRepository[{pascal}], {pascal}Repository):
+    pass  # TODO: add custom query methods if needed
+""",
+    "mongodb": """\
+from arclith.adapters.output.mongodb.config import MongoDBConfig
+from arclith.adapters.output.mongodb.repository import MongoDBRepository
+from arclith.domain.ports.logger import Logger
+from domain.models.{snake} import {pascal}
+from domain.ports.output.{snake}_repository import {pascal}Repository
+
+
+class MongoDB{pascal}Repository(MongoDBRepository[{pascal}], {pascal}Repository):
+    def __init__(self, config: MongoDBConfig, logger: Logger) -> None:
+        super().__init__(config, {pascal}, logger)
+
+    # TODO: add custom query methods here
+    # async def find_by_name(self, name: str) -> list[{pascal}]:
+    #     async with self._collection() as col:
+    #         return [
+    #             self._from_doc(doc)
+    #             async for doc in col.find({{"name": name, "deleted_at": None}})
+    #         ]
+""",
+    "duckdb": """\
+from arclith.adapters.output.duckdb.repository import DuckDBRepository
+from domain.models.{snake} import {pascal}
+from domain.ports.output.{snake}_repository import {pascal}Repository
+
+
+class DuckDB{pascal}Repository(DuckDBRepository[{pascal}], {pascal}Repository):
+    def __init__(self, path: str) -> None:
+        super().__init__(path, {pascal})
+
+    # TODO: add custom query methods here
+    # async def find_by_name(self, name: str) -> list[{pascal}]:
+    #     rows = self._fetch(
+    #         f"SELECT * FROM {{self._table}} WHERE deleted_at IS NULL AND lower(name) LIKE ?",
+    #         [f"%{{name.lower()}}%"],
+    #     )
+    #     return [self._row_to_entity(r) for r in rows]
+""",
+}
+
+# ── repository.py re-export template ─────────────────────────────────────────
+
+REPO_REEXPORT: dict[str, str] = {
+    "memory": """\
+from adapters.output.memory.repositories.{snake}_repository import InMemory{pascal}Repository
+
+__all__ = ["InMemory{pascal}Repository"]
+""",
+    "mongodb": """\
+from adapters.output.mongodb.repositories.{snake}_repository import MongoDB{pascal}Repository
+
+__all__ = ["MongoDB{pascal}Repository"]
+""",
+    "duckdb": """\
+from adapters.output.duckdb.repositories.{snake}_repository import DuckDB{pascal}Repository
+
+__all__ = ["DuckDB{pascal}Repository"]
+""",
+}
+
+# ── Container template (full file, regenerated with all installed adapters) ───
+
+_CONTAINER_HEADER = """\
+from __future__ import annotations
+
+from application.services.{snake}_service import {pascal}Service
+from arclith import Arclith, AdapterRegistry
+from arclith.infrastructure.config import AppConfig
+from arclith.domain.ports.logger import Logger
+from domain.models.{snake} import {pascal}
+from domain.ports.output.{snake}_repository import {pascal}Repository
+
+"""
+
+_CONTAINER_FACTORY: dict[str, str] = {
+    "memory": """\
+def _build_memory(cfg: AppConfig, log: Logger) -> {pascal}Repository:
+    from adapters.output.memory.repository import InMemory{pascal}Repository
+    return InMemory{pascal}Repository()
+
+""",
+    "mongodb": """\
+def _build_mongodb(cfg: AppConfig, log: Logger) -> {pascal}Repository:
+    from adapters.output.mongodb.repository import MongoDB{pascal}Repository
+    from arclith.adapters.output.mongodb.config import MongoDBConfig
+    mongo = cfg.adapters.mongodb
+    if mongo is None:
+        raise RuntimeError("MongoDB settings are required when repository=mongodb")
+    return MongoDB{pascal}Repository(MongoDBConfig(uri=mongo.uri, db_name=mongo.db_name), log)
+
+""",
+    "duckdb": """\
+def _build_duckdb(cfg: AppConfig, log: Logger) -> {pascal}Repository:
+    from adapters.output.duckdb.repository import DuckDB{pascal}Repository
+    duckdb = cfg.adapters.duckdb
+    if duckdb is None:
+        raise RuntimeError("DuckDB settings are required when repository=duckdb")
+    return DuckDB{pascal}Repository(duckdb.path)
+
+""",
+}
+
+_CONTAINER_FOOTER = """\
+_registry: AdapterRegistry[{pascal}] = (
+    AdapterRegistry()
+{registrations}
+)
+
+
+def build_{snake}_service(arclith: Arclith) -> tuple[{pascal}Service, Logger]:
+    arclith.logger.info("🗄️ Repository adapter selected", adapter=arclith.config.adapters.repository)
+    repo: {pascal}Repository = _registry.build(arclith.config, arclith.logger)
+    return {pascal}Service(repo, arclith.logger, arclith.config.soft_delete.retention_days), arclith.logger
+"""
+
+
+def render_container(pascal: str, snake: str, installed_adapters: list[str]) -> str:
+    """Generate the full container file content for a given entity and its adapters."""
+    # memory is always included (arclith built-in, needs no extra files)
+    adapters = list(dict.fromkeys(["memory"] + installed_adapters))
+
+    header = _CONTAINER_HEADER.format(pascal=pascal, snake=snake)
+    factories = "".join(
+        _CONTAINER_FACTORY[a].format(pascal=pascal, snake=snake)
+        for a in adapters
+        if a in _CONTAINER_FACTORY
+    )
+    registrations = "\n".join(
+        f"    .register(\"{a}\", _build_{a})"
+        for a in adapters
+        if a in _CONTAINER_FACTORY
+    )
+    footer = _CONTAINER_FOOTER.format(pascal=pascal, snake=snake, registrations=registrations)
+    return header + factories + footer
+
+
+def render(template: str, vars: dict[str, Any]) -> str:
+    return template.format(**vars)
+

arclith_cli/add_adapter.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from .adapter_templates import (
+    CONFIG_YAML,
+    REPO_PYTHON,
+    REPO_REEXPORT,
+    SUPPORTED_ADAPTERS,
+    render,
+    render_container,
+)
+from .entity_scanner import EntityInfo, scan_entities, scan_installed_adapters
+
+console = Console()
+
+
+# ── Entry point ───────────────────────────────────────────────────────────────
+
+def add_adapter_cmd() -> None:
+    """Wizard interactif pour scaffolder un nouvel adapter output."""
+    project_dir = Path.cwd()
+
+    _assert_arclith_project(project_dir)
+
+    adapter = _prompt_adapter_type()
+    entities = _prompt_entities(project_dir)
+    params = _prompt_adapter_params(adapter, project_dir)
+    activate = Confirm.ask(
+        f"\n  [bold]Activer[/bold] [green]{adapter}[/green] maintenant ?",
+        default=True,
+    )
+
+    _show_recap(project_dir, adapter, entities, params, activate)
+
+    if not Confirm.ask("\n  [bold]Confirmer la génération ?[/bold]", default=True):
+        console.print("[yellow]Annulé.[/yellow]")
+        raise typer.Exit(0)
+
+    _generate(project_dir, adapter, entities, params, activate)
+
+
+# ── Validation ────────────────────────────────────────────────────────────────
+
+def _assert_arclith_project(project_dir: Path) -> None:
+    if not (project_dir / "domain" / "models").exists():
+        console.print(
+            "[red]✗[/red] Aucun dossier [bold]domain/models/[/bold] trouvé.\n"
+            "    Exécutez [bold]arclith-cli add-adapter[/bold] depuis la racine d'un projet arclith."
+        )
+        raise typer.Exit(1)
+    if not (project_dir / "config" / "adapters").exists():
+        console.print(
+            "[red]✗[/red] Aucun dossier [bold]config/adapters/[/bold] trouvé.\n"
+            "    Le projet doit utiliser la structure [bold]config/[/bold] directory."
+        )
+        raise typer.Exit(1)
+
+
+# ── Step 1 : adapter type ─────────────────────────────────────────────────────
+
+def _prompt_adapter_type() -> str:
+    console.print("\n[bold]① Type d'adapter[/bold]")
+    for i, name in enumerate(SUPPORTED_ADAPTERS, 1):
+        console.print(f"   [bold cyan]{i}[/bold cyan]  {name}")
+
+    while True:
+        raw = Prompt.ask("\n  Votre choix [dim](numéro ou nom)[/dim]").strip()
+        if raw.isdigit():
+            idx = int(raw) - 1
+            if 0 <= idx < len(SUPPORTED_ADAPTERS):
+                return SUPPORTED_ADAPTERS[idx]
+        elif raw in SUPPORTED_ADAPTERS:
+            return raw
+        console.print(f"  [red]Choix invalide.[/red] Entrez 1-{len(SUPPORTED_ADAPTERS)} ou le nom.")
+
+
+# ── Step 2 : entity selection ─────────────────────────────────────────────────
+
+def _prompt_entities(project_dir: Path) -> list[EntityInfo]:
+    entities = scan_entities(project_dir)
+    if not entities:
+        console.print("[red]✗[/red] Aucune entité trouvée dans [bold]domain/models/[/bold].")
+        raise typer.Exit(1)
+
+    console.print("\n[bold]② Entité(s) cible(s)[/bold]")
+    for i, e in enumerate(entities, 1):
+        console.print(f"   [bold cyan]{i}[/bold cyan]  {e.pascal} [dim]({e.snake})[/dim]")
+    console.print(f"   [bold cyan]{len(entities) + 1}[/bold cyan]  [italic]toutes[/italic]")
+
+    while True:
+        raw = Prompt.ask("\n  Votre choix [dim](numéro(s) séparés par virgule, ou nom)[/dim]").strip()
+        selected = _parse_entity_choice(raw, entities)
+        if selected is not None:
+            return selected
+        console.print("  [red]Choix invalide.[/red]")
+
+
+def _parse_entity_choice(raw: str, entities: list[EntityInfo]) -> list[EntityInfo] | None:
+    all_idx = len(entities) + 1
+    parts = [p.strip() for p in raw.split(",") if p.strip()]
+    result: list[EntityInfo] = []
+    for part in parts:
+        if part.isdigit():
+            idx = int(part)
+            if idx == all_idx:
+                return list(entities)
+            if 1 <= idx <= len(entities):
+                e = entities[idx - 1]
+                if e not in result:
+                    result.append(e)
+            else:
+                return None
+        else:
+            matched = [e for e in entities if e.pascal == part or e.snake == part]
+            if not matched:
+                return None
+            for e in matched:
+                if e not in result:
+                    result.append(e)
+    return result or None
+
+
+# ── Step 3 : adapter-specific params ─────────────────────────────────────────
+
+def _prompt_adapter_params(adapter: str, project_dir: Path) -> dict:
+    console.print(f"\n[bold]③ Paramètres [green]{adapter}[/green][/bold]")
+
+    if adapter == "mongodb":
+        project_name = project_dir.name
+        db_name = Prompt.ask(
+            "  db_name",
+            default=project_name,
+        ).strip()
+        multitenant = Confirm.ask("  multitenant", default=False)
+        return {"db_name": db_name, "multitenant": multitenant}
+
+    if adapter == "duckdb":
+        path = Prompt.ask("  path", default="data/").strip()
+        return {"path": path}
+
+    console.print("  [dim](aucun paramètre requis)[/dim]")
+    return {}
+
+
+# ── Step 4 : recap ────────────────────────────────────────────────────────────
+
+def _show_recap(
+    project_dir: Path,
+    adapter: str,
+    entities: list[EntityInfo],
+    params: dict,
+    activate: bool,
+) -> None:
+    installed = scan_installed_adapters(project_dir)
+    files = _list_generated_files(project_dir, adapter, entities, installed)
+
+    table = Table(show_header=True, header_style="bold blue", box=None, padding=(0, 2))
+    table.add_column("Fichier")
+    table.add_column("Action", style="dim")
+
+    for path, action in files:
+        style = "yellow" if action == "remplacé ⚠" else "green"
+        table.add_row(str(path.relative_to(project_dir)), f"[{style}]{action}[/{style}]")
+
+    if activate:
+        cfg_path = project_dir / "config" / "adapters" / "adapters.yaml"
+        table.add_row(
+            str(cfg_path.relative_to(project_dir)),
+            "[cyan]mis à jour (repository)[/cyan]",
+        )
+
+    console.print()
+    console.print(Panel(table, title=f"[bold]Récapitulatif — adapter [green]{adapter}[/green][/bold]"))
+
+
+def _list_generated_files(
+    project_dir: Path,
+    adapter: str,
+    entities: list[EntityInfo],
+    installed: list[str],
+) -> list[tuple[Path, str]]:
+    files: list[tuple[Path, str]] = []
+
+    if adapter != "memory" and CONFIG_YAML.get(adapter):
+        cfg = project_dir / "config" / "adapters" / "output" / f"{adapter}.yaml"
+        files.append((cfg, "remplacé ⚠" if cfg.exists() else "créé"))
+
+    for entity in entities:
+        base = project_dir / "adapters" / "output" / adapter
+        repo_dir = base / "repositories"
+        repo_file = repo_dir / f"{entity.snake}_repository.py"
+        reexport = base / "repository.py"
+        init = base / "__init__.py"
+        container = project_dir / "infrastructure" / "containers" / f"{entity.snake}_container.py"
+
+        files.append((init, "remplacé ⚠" if init.exists() else "créé"))
+        files.append((repo_file, "remplacé ⚠" if repo_file.exists() else "créé"))
+        files.append((reexport, "remplacé ⚠" if reexport.exists() else "créé"))
+        files.append((container, "remplacé ⚠" if container.exists() else "créé"))
+
+    return files
+
+
+# ── Step 5 : generate ─────────────────────────────────────────────────────────
+
+def _generate(
+    project_dir: Path,
+    adapter: str,
+    entities: list[EntityInfo],
+    params: dict,
+    activate: bool,
+) -> None:
+    installed = scan_installed_adapters(project_dir)
+    if adapter not in installed:
+        installed = sorted(installed + [adapter])
+
+    # Config YAML (skip memory — no config needed)
+    if adapter != "memory":
+        yaml_content = CONFIG_YAML.get(adapter, "")
+        if yaml_content:
+            cfg_path = project_dir / "config" / "adapters" / "output" / f"{adapter}.yaml"
+            cfg_path.parent.mkdir(parents=True, exist_ok=True)
+            cfg_path.write_text(render(yaml_content, params))
+            console.print(f"[green]✓[/green] {cfg_path.relative_to(project_dir)}")
+
+    for entity in entities:
+        vars = {"pascal": entity.pascal, "snake": entity.snake, **params}
+        base = project_dir / "adapters" / "output" / adapter
+        repo_dir = base / "repositories"
+        repo_dir.mkdir(parents=True, exist_ok=True)
+
+        # __init__.py
+        init_file = base / "__init__.py"
+        if not init_file.exists():
+            init_file.write_text("")
+        # repositories/__init__.py
+        repo_init_file = repo_dir / "__init__.py"
+        if not repo_init_file.exists():
+            repo_init_file.write_text("")
+            console.print(f"[green]✓[/green] {repo_init_file.relative_to(project_dir)}")
+
+        # Repository subclass
+        repo_file = repo_dir / f"{entity.snake}_repository.py"
+        repo_file.write_text(render(REPO_PYTHON[adapter], vars))
+        console.print(f"[green]✓[/green] {repo_file.relative_to(project_dir)}")
+
+        # Re-export
+        reexport = base / "repository.py"
+        reexport.write_text(render(REPO_REEXPORT[adapter], vars))
+        console.print(f"[green]✓[/green] {reexport.relative_to(project_dir)}")
+
+        # Container (full regeneration)
+        container = project_dir / "infrastructure" / "containers" / f"{entity.snake}_container.py"
+        existed = container.exists()
+        container.parent.mkdir(parents=True, exist_ok=True)
+        container.write_text(render_container(entity.pascal, entity.snake, installed))
+        action = "[yellow]remplacé ⚠[/yellow]" if existed else "[green]créé[/green]"
+        console.print(f"{action} {container.relative_to(project_dir)}")
+
+    # Activate: update config/adapters/adapters.yaml
+    if activate:
+        _update_active_adapter(project_dir, adapter)
+
+    console.print(f"\n[bold green]✓ Adapter [cyan]{adapter}[/cyan] scaffoldé avec succès.[/bold green]")
+
+
+def _update_active_adapter(project_dir: Path, adapter: str) -> None:
+    import re
+    cfg = project_dir / "config" / "adapters" / "adapters.yaml"
+    if not cfg.exists():
+        cfg.parent.mkdir(parents=True, exist_ok=True)
+        cfg.write_text(f"repository: {adapter}\n")
+    else:
+        text = cfg.read_text()
+        if re.search(r"(?m)^repository:", text):
+            text = re.sub(r"(?m)^(repository:\s*).*$", rf"\g<1>{adapter}", text)
+        else:
+            text = text.rstrip("\n") + f"\nrepository: {adapter}\n"
+        cfg.write_text(text)
+    console.print(f"[cyan]↺[/cyan] config/adapters/adapters.yaml → repository: {adapter}")
+

arclith_cli/entity_scanner.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class EntityInfo:
+    pascal: str   # Ingredient
+    snake: str    # ingredient
+    file_path: Path
+
+
+def scan_entities(project_dir: Path) -> list[EntityInfo]:
+    """Scan domain/models/*.py via AST to find Entity subclasses.
+
+    Extracts any class that directly names 'Entity' as a base.
+    Parsing errors are silently skipped so a broken file never blocks the wizard.
+    """
+    models_dir = project_dir / "domain" / "models"
+    if not models_dir.exists():
+        return []
+
+    entities: list[EntityInfo] = []
+    for py_file in sorted(models_dir.glob("*.py")):
+        if py_file.name.startswith("_"):
+            continue
+        try:
+            tree = ast.parse(py_file.read_text(encoding="utf-8"))
+        except (SyntaxError, UnicodeDecodeError):
+            continue
+        for node in ast.walk(tree):
+            if not isinstance(node, ast.ClassDef):
+                continue
+            base_names = {
+                b.id if isinstance(b, ast.Name)
+                else b.attr if isinstance(b, ast.Attribute)
+                else ""
+                for b in node.bases
+            }
+            if "Entity" in base_names:
+                entities.append(EntityInfo(
+                    pascal=node.name,
+                    snake=_to_snake(node.name),
+                    file_path=py_file,
+                ))
+    return entities
+
+
+def scan_installed_adapters(project_dir: Path) -> list[str]:
+    """Return adapter names found under adapters/output/ (subdirectory names)."""
+    output_dir = project_dir / "adapters" / "output"
+    if not output_dir.exists():
+        return []
+    return sorted(
+        p.name for p in output_dir.iterdir()
+        if p.is_dir() and not p.name.startswith("_")
+    )
+
+
+def _to_snake(pascal: str) -> str:
+    import re
+    s = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", pascal)
+    s = re.sub(r"([a-z\d])([A-Z])", r"\1_\2", s)
+    return s.lower()
+

arclith_cli/export_config.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def export_config_cmd(
+    output: Annotated[
+        Path,
+        typer.Option("--output", "-o", help="Chemin du fichier YAML généré"),
+    ] = Path("config.yaml"),
+) -> None:
+    """Générer un [bold]config.yaml[/bold] unifié depuis le dossier [bold]config/[/bold].
+
+    Utile pour le déploiement Kubernetes — le fichier généré peut être monté
+    directement comme [bold]ConfigMap[/bold]. Arclith l'accepte en lecture via
+    [dim]Arclith("config.yaml")[/dim] au même titre que le dossier [dim]config/[/dim].
+    """
+    project_dir = Path.cwd()
+    config_dir = project_dir / "config"
+
+    if not config_dir.is_dir():
+        console.print(
+            "[red]✗[/red] Aucun dossier [bold]config/[/bold] trouvé.\n"
+            "    Exécutez depuis la racine d'un projet arclith."
+        )
+        raise typer.Exit(1)
+
+    output_path = output if output.is_absolute() else project_dir / output
+
+    if output_path.exists():
+        from rich.prompt import Confirm
+        if not Confirm.ask(f"  [yellow]{output_path.relative_to(project_dir)}[/yellow] existe déjà. Écraser ?", default=True):
+            console.print("[yellow]Annulé.[/yellow]")
+            raise typer.Exit(0)
+
+    try:
+        from arclith.infrastructure.config import export_config_yaml
+        export_config_yaml(config_dir, output_path)
+    except Exception as exc:
+        console.print(f"[red]✗ Erreur :[/red] {exc}")
+        raise typer.Exit(1) from exc
+
+    try:
+        rel = output_path.relative_to(project_dir)
+        display_path = str(rel)
+    except ValueError:
+        # output_path is outside project_dir (e.g., /tmp/config.yaml)
+        display_path = str(output_path)
+    
+    console.print(
+        Panel.fit(
+            f"[green]✓[/green] [bold]{display_path}[/bold] généré depuis [dim]config/[/dim]\n\n"
+            f"  [bold cyan]Kubernetes[/bold cyan]  Monter ce fichier comme ConfigMap\n"
+            f"  [bold cyan]Arclith[/bold cyan]     [dim]Arclith(\"{display_path}\")[/dim]  ←  identique à  [dim]Arclith(\"config/\")[/dim]\n\n"
+            f"  [dim]⚠ Fichier généré — ne pas éditer manuellement.[/dim]\n"
+            f"  [dim]  Ajouter [bold]config.yaml[/bold] à .gitignore[/dim]",
+            border_style="green",
+            title="[bold]export-config[/bold]",
+        )
+
+    )
+