arclith-cli 0.7.1__py3-none-any.whl

arclith_cli/main.py

@@ -0,0 +1,199 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.tree import Tree
+
+from . import __version__
+from .add_adapter import add_adapter_cmd
+from .export_config import export_config_cmd
+from .rename import EntityNames, apply_rename
+from .scaffold import download_and_extract
+from .updater import run_update
+
+app = typer.Typer(
+    name="arclith-cli",
+    help="Scaffold [bold]arclith[/bold] hexagonal projects from the official template.",
+    no_args_is_help=False,
+    rich_markup_mode="rich",
+)
+console = Console()
+
+_ENTITY_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_\-]*$")
+_PROJECT_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_\-]*$")
+
+
+@app.command()
+def new(
+    entity: Annotated[
+        str | None,
+        typer.Argument(
+            help="Nom de l'entité au [bold]singulier[/bold] — tout format accepté : [dim]Recipe[/dim], [dim]recipe_step[/dim], [dim]meal-plan[/dim]",
+        ),
+    ] = None,
+    project_name: Annotated[
+        str | None,
+        typer.Argument(help="Nom du répertoire du projet. Exemple : [dim]my-recipe-service[/dim]"),
+    ] = None,
+    directory: Annotated[
+        Path,
+        typer.Option("--dir", "-d", help="Répertoire parent où le projet sera créé"),
+    ] = Path("."),
+    port: Annotated[
+        int,
+        typer.Option("--port", "-p", help="Port REST (MCP = port+1)"),
+    ] = 8000,
+    repo_ref: Annotated[
+        str,
+        typer.Option("--ref", help="Branche ou tag Git du template _sample"),
+    ] = "main",
+) -> None:
+    """Créer un nouveau projet [bold]arclith[/bold] scaffoldé depuis le template officiel [dim]_sample[/dim]."""
+    entity = entity or _prompt_entity()
+    project_name = project_name or _prompt_project()
+
+    names = EntityNames.from_input(entity)
+    target_dir = directory.resolve() / project_name
+
+    if target_dir.exists():
+        console.print(f"[red]✗[/red] Le répertoire existe déjà : [bold]{target_dir}[/bold]")
+        raise typer.Exit(1)
+
+    console.print(
+        Panel.fit(
+            f"[bold blue]arclith-cli[/bold blue] [dim]v{__version__}[/dim]\n\n"
+            f"  Entité   [bold green]{names.pascal}[/bold green]  [dim]({names.snake} / {names.upper})[/dim]\n"
+            f"  Projet   [bold]{project_name}[/bold]\n"
+            f"  Cible    [dim]{target_dir}[/dim]\n"
+            f"  Ports    REST [bold]{port}[/bold]  ·  MCP [bold]{port + 1}[/bold]",
+            border_style="blue",
+            title="[bold]Nouveau projet[/bold]",
+        )
+    )
+
+    with console.status("[bold]Téléchargement du template depuis GitHub…[/bold]"):
+        try:
+            download_and_extract(target_dir, ref=repo_ref)
+        except Exception as exc:
+            console.print(f"[red]✗ Téléchargement échoué :[/red] {exc}")
+            raise typer.Exit(1) from exc
+
+    console.print("[green]✓[/green] Template extrait")
+
+    with console.status("[bold]Renommage de l'entité…[/bold]"):
+        apply_rename(target_dir, names, project_name=project_name, port=port)
+
+    console.print("[green]✓[/green] Renommage terminé")
+    _print_summary(target_dir, project_name, port)
+
+
+@app.command()
+def update(
+    ref: Annotated[
+        str | None,
+        typer.Option("--ref", help="Branche ou tag Git cible (défaut : main)"),
+    ] = None,
+) -> None:
+    """Mettre à jour arclith-cli vers la dernière version depuis GitHub."""
+    run_update(ref=ref)
+
+
+@app.command()
+def version() -> None:
+    """Show the arclith-cli version."""
+    console.print(f"arclith-cli [bold]{__version__}[/bold]")
+
+
+@app.command(name="add-adapter")
+def add_adapter() -> None:
+    """Wizard interactif pour scaffolder un nouvel [bold]adapter output[/bold] dans le projet courant."""
+    add_adapter_cmd()
+
+
+@app.command(name="export-config")
+def export_config(
+    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 [bold]config/[/bold] pour déploiement K8s."""
+    export_config_cmd(output=output)
+
+
+# ── Prompts interactifs ───────────────────────────────────────────────────────
+
+def _prompt_entity() -> str:
+    console.print(
+        "\n[bold]Entité[/bold] — utilisez le [yellow]singulier[/yellow] "
+        "[dim](ex : Recipe, recipe_step, MealPlan)[/dim]"
+    )
+    while True:
+        value = Prompt.ask("  [bold green]Nom de l'entité[/bold green]").strip()
+        if not value:
+            console.print("  [red]Le nom ne peut pas être vide.[/red]")
+        elif not _ENTITY_RE.match(value):
+            console.print(
+                "  [red]Caractères invalides.[/red] "
+                "[dim]Lettres, chiffres, _ et - uniquement. Doit commencer par une lettre.[/dim]"
+            )
+        else:
+            return value
+
+
+def _prompt_project() -> str:
+    console.print("\n[bold]Projet[/bold] [dim](ex : my-recipe-service, meal-planner)[/dim]")
+    while True:
+        value = Prompt.ask("  [bold green]Nom du projet[/bold green]").strip()
+        if not value:
+            console.print("  [red]Le nom ne peut pas être vide.[/red]")
+        elif not _PROJECT_RE.match(value):
+            console.print(
+                "  [red]Caractères invalides.[/red] "
+                "[dim]Lettres, chiffres, _ et - uniquement. Doit commencer par une lettre.[/dim]"
+            )
+        else:
+            return value
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _print_summary(target_dir: Path, project_name: str, port: int) -> None:
+    tree = Tree(f"[bold green]{project_name}/[/bold green]")
+    _build_tree(tree, target_dir, depth=0, max_depth=3)
+    console.print()
+    console.print(tree)
+    console.print(
+        Panel(
+            f"[bold cyan]cd[/bold cyan] {target_dir}\n"
+            f"[bold cyan]uv sync[/bold cyan]\n\n"
+            f"[bold cyan]uv run python main.py[/bold cyan]"
+            f"  [dim]# MODE=api → REST :{port}[/dim]\n"
+            f"[bold cyan]MODE=mcp_http uv run python main.py[/bold cyan]"
+            f"  [dim]# MCP :{port + 1}[/dim]",
+            title="[bold blue]Next steps[/bold blue]",
+            border_style="green",
+        )
+    )
+
+
+def _build_tree(node: Tree, path: Path, depth: int, max_depth: int) -> None:
+    if depth >= max_depth:
+        return
+    try:
+        children = sorted(path.iterdir(), key=lambda p: (p.is_file(), p.name))
+    except PermissionError:
+        return
+    for child in children:
+        if child.name.startswith("."):
+            continue
+        label = f"[blue]{child.name}/[/blue]" if child.is_dir() else child.name
+        branch = node.add(label)
+        if child.is_dir():
+            _build_tree(branch, child, depth + 1, max_depth)

arclith_cli/rename.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+_SOURCE_PASCAL = "Ingredient"
+_SOURCE_SNAKE = "ingredient"
+_SOURCE_UPPER = "INGREDIENT"
+
+_TEXT_EXTENSIONS = {
+    ".py", ".yaml", ".yml", ".toml", ".md", ".txt", ".json",
+    ".cfg", ".ini", ".env", ".sh", ".rst",
+}
+
+
+@dataclass(frozen=True)
+class EntityNames:
+    pascal: str  # RecipeStep
+    snake: str   # recipe_step
+    upper: str   # RECIPE_STEP
+
+    @classmethod
+    def from_input(cls, raw: str) -> "EntityNames":
+        pascal = _to_pascal(raw)
+        snake = _to_snake(raw)
+        return cls(pascal=pascal, snake=snake, upper=snake.upper())
+
+
+def apply_rename(target_dir: Path, names: EntityNames, *, project_name: str, port: int) -> None:
+    _rename_file_contents(target_dir, names)
+    _rename_paths(target_dir, names)
+    _patch_pyproject(target_dir, project_name)
+    _patch_config(target_dir, project_name, port)
+
+
+# ── Content replacement ───────────────────────────────────────────────────────
+
+def _replace_in_text(text: str, names: EntityNames) -> str:
+    # Order: most specific first to avoid partial overlap (UPPER before lower)
+    return (
+        text
+        .replace(_SOURCE_UPPER, names.upper)
+        .replace(_SOURCE_PASCAL, names.pascal)
+        .replace(_SOURCE_SNAKE, names.snake)
+    )
+
+
+def _rename_file_contents(directory: Path, names: EntityNames) -> None:
+    for path in directory.rglob("*"):
+        if not path.is_file():
+            continue
+        if path.suffix.lower() not in _TEXT_EXTENSIONS and path.suffix != "":
+            continue
+        try:
+            text = path.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, PermissionError):
+            continue
+        new_text = _replace_in_text(text, names)
+        if new_text != text:
+            path.write_text(new_text, encoding="utf-8")
+
+
+# ── Path renaming ─────────────────────────────────────────────────────────────
+
+def _rename_paths(directory: Path, names: EntityNames) -> None:
+    # Deepest first so parent renames don't invalidate children
+    candidates = sorted(
+        directory.rglob("*"),
+        key=lambda p: len(p.parts),
+        reverse=True,
+    )
+    for path in candidates:
+        if not path.exists():
+            continue
+        if not any(tok in path.name for tok in (_SOURCE_SNAKE, _SOURCE_PASCAL, _SOURCE_UPPER)):
+            continue
+        new_name = _replace_in_text(path.name, names)
+        if new_name != path.name:
+            path.rename(path.parent / new_name)
+
+
+# ── pyproject.toml patching ───────────────────────────────────────────────────
+
+def _patch_pyproject(target_dir: Path, project_name: str) -> None:
+    p = target_dir / "pyproject.toml"
+    if not p.exists():
+        return
+    text = p.read_text()
+    # Update project name (first occurrence)
+    text = re.sub(r'(?m)^name\s*=\s*"[^"]*"', f'name = "{project_name}"', text, count=1)
+    # Remove [tool.uv.sources] block (editable arclith path)
+    text = re.sub(
+        r"\[tool\.uv\.sources\]\n(?:[^\[]*)",
+        "",
+        text,
+        flags=re.DOTALL,
+    )
+    p.write_text(text.strip() + "\n")
+
+
+# ── config/ directory patching ────────────────────────────────────────────────
+
+def _patch_config(target_dir: Path, project_name: str, port: int) -> None:
+    _patch_yaml_field(target_dir / "config" / "app.yaml", "name", project_name)
+    _patch_yaml_field(
+        target_dir / "config" / "app.yaml",
+        "description",
+        f'"{project_name} — built on arclith"',
+    )
+    _patch_yaml_field(
+        target_dir / "config" / "adapters" / "output" / "mongodb.yaml",
+        "db_name",
+        project_name,
+    )
+    _patch_section_port(
+        target_dir / "config" / "adapters" / "input" / "fastapi.yaml",
+        port,
+    )
+    _patch_section_port(
+        target_dir / "config" / "adapters" / "input" / "fastmcp.yaml",
+        port + 1,
+    )
+
+
+def _patch_yaml_field(path: Path, key: str, value: str) -> None:
+    if not path.exists():
+        return
+    text = path.read_text()
+    text = re.sub(rf"(?m)(^{re.escape(key)}:\s*).*$", rf"\g<1>{value}", text, count=1)
+    path.write_text(text)
+
+
+def _patch_section_port(path: Path, new_port: int) -> None:
+    if not path.exists():
+        return
+    text = path.read_text()
+    text = re.sub(r"(?m)(^port:\s*)\d+", rf"\g<1>{new_port}", text, count=1)
+    path.write_text(text)
+
+
+# ── Case converters ───────────────────────────────────────────────────────────
+
+def _to_pascal(raw: str) -> str:
+    if "_" in raw or "-" in raw:
+        return "".join(w.capitalize() for w in re.split(r"[_\-]", raw) if w)
+    return raw[0].upper() + raw[1:] if raw else raw
+
+
+def _to_snake(raw: str) -> str:
+    if "_" in raw:
+        return raw.lower()
+    if "-" in raw:
+        return raw.replace("-", "_").lower()
+    # PascalCase / camelCase → snake_case
+    s = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", raw)
+    s = re.sub(r"([a-z\d])([A-Z])", r"\1_\2", s)
+    return s.lower()
+

arclith_cli/scaffold.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import io
+import shutil
+import zipfile
+from pathlib import Path
+
+import httpx
+
+_TEMPLATE_URL = "https://github.com/karned-rekipe/_sample/archive/refs/heads/{ref}.zip"
+
+_DIRS_TO_REMOVE = {
+    "__pycache__", ".venv", ".mypy_cache", ".pytest_cache",
+    ".ruff_cache", ".idea", ".github", ".git", ".files", ".dev", "htmlcov",
+}
+_FILES_TO_REMOVE = {
+    ".coverage", "uv.lock", "AGENTS.md", "README.md", ".gitignore", "config.yaml",
+}
+_DATA_FILES_TO_REMOVE = {"ingredient.csv"}
+
+
+def download_and_extract(target_dir: Path, *, ref: str = "main") -> None:
+    url = _TEMPLATE_URL.format(ref=ref)
+    response = httpx.get(url, follow_redirects=True, timeout=60)
+    response.raise_for_status()
+
+    with zipfile.ZipFile(io.BytesIO(response.content)) as zf:
+        root_prefix = _zip_root(zf)
+        target_dir.mkdir(parents=True, exist_ok=False)
+        for member in zf.infolist():
+            rel = member.filename[len(root_prefix):]
+            if not rel:
+                continue
+            dest = target_dir / rel
+            if member.is_dir():
+                dest.mkdir(parents=True, exist_ok=True)
+            else:
+                dest.parent.mkdir(parents=True, exist_ok=True)
+                dest.write_bytes(zf.read(member.filename))
+
+    _cleanup(target_dir)
+
+
+def _zip_root(zf: zipfile.ZipFile) -> str:
+    return zf.namelist()[0].split("/")[0] + "/"
+
+
+def _cleanup(target_dir: Path) -> None:
+    # Dirs (traverse deepest first to handle nested __pycache__)
+    for item in sorted(target_dir.rglob("*"), key=lambda p: len(p.parts), reverse=True):
+        if item.is_dir() and item.name in _DIRS_TO_REMOVE:
+            shutil.rmtree(item, ignore_errors=True)
+        elif item.is_file() and item.name in _FILES_TO_REMOVE:
+            item.unlink(missing_ok=True)
+
+    # Data files
+    data_dir = target_dir / "data"
+    if data_dir.exists():
+        for fname in _DATA_FILES_TO_REMOVE:
+            (data_dir / fname).unlink(missing_ok=True)
+        try:
+            data_dir.rmdir()  # only succeeds if empty
+        except OSError:
+            pass
+

arclith_cli/updater.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from typing import Annotated
+
+import typer
+from rich.console import Console
+
+_INSTALL_URL = "git+https://github.com/karned-rekipe/framework.git#subdirectory=cli"
+
+console = Console()
+
+
+def run_update(ref: str | None = None) -> None:
+    uv = shutil.which("uv")
+    if not uv:
+        console.print(
+            "[red]✗[/red] [bold]uv[/bold] introuvable dans le PATH.\n"
+            "Installez-le : [link=https://docs.astral.sh/uv/]https://docs.astral.sh/uv/[/link]"
+        )
+        raise typer.Exit(1)
+
+    url = _INSTALL_URL if not ref else _INSTALL_URL.replace(".git#", f".git@{ref}#")
+    console.print(f"[bold]Mise à jour depuis[/bold] [dim]{url}[/dim]")
+
+    result = subprocess.run([uv, "tool", "install", "--force", url])
+    if result.returncode == 0:
+        console.print("[green]✓[/green] arclith-cli mis à jour")
+    else:
+        console.print("[red]✗[/red] Échec de la mise à jour")
+        raise typer.Exit(result.returncode)
+

arclith_cli-0.7.1.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: arclith-cli
+Version: 0.7.1
+Summary: CLI scaffolding tool for arclith — hexagonal architecture framework
+Author-email: Killian KOPP <killiankopp@gmail.com>
+License:                                  Apache License
+                                   Version 2.0, January 2004
+                                http://www.apache.org/licenses/
+        
+           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+        
+           1. Definitions.
+        
+              "License" shall mean the terms and conditions for use, reproduction,
+              and distribution as defined by Sections 1 through 9 of this document.
+        
+              "Licensor" shall mean the copyright owner or entity authorized by
+              the copyright owner that is granting the License.
+        
+              "Legal Entity" shall mean the union of the acting entity and all
+              other entities that control, are controlled by, or are under common
+              control with that entity. For the purposes of this definition,
+              "control" means (i) the power, direct or indirect, to cause the
+              direction or management of such entity, whether by contract or
+              otherwise, or (ii) ownership of fifty percent (50%) or more of the
+              outstanding shares, or (iii) beneficial ownership of such entity.
+        
+              "You" (or "Your") shall mean an individual or Legal Entity
+              exercising permissions granted by this License.
+        
+              "Source" form shall mean the preferred form for making modifications,
+              including but not limited to software source code, documentation
+              source, and configuration files.
+        
+              "Object" form shall mean any form resulting from mechanical
+              transformation or translation of a Source form, including but
+              not limited to compiled object code, generated documentation,
+              and conversions to other media types.
+        
+              "Work" shall mean the work of authorship made available under
+              the License, as indicated by a copyright notice that is included in
+              or attached to the work (an example is provided in the Appendix below).
+        
+              "Derivative Works" shall mean any work, whether in Source or Object
+              form, that is based on (or derived from) the Work and for which the
+              editorial revisions, annotations, elaborations, or other modifications
+              represent, as a whole, an original work of authorship. For the purposes
+              of this License, Derivative Works shall not include works that remain
+              separable from, or merely link (or bind by name) to the interfaces of,
+              the Work and its Derivative Works thereof.
+        
+              "Contribution" shall mean, as submitted to the Licensor for inclusion
+              in the Work by the copyright owner or by an individual or Legal Entity
+              authorized to submit on behalf of the copyright owner. For the purposes
+              of this definition, "submitted" means any form of electronic, verbal,
+              or written communication sent to the Licensor or its representatives,
+              including but not limited to communication on electronic mailing lists,
+              source code control systems, and issue tracking systems that are managed
+              by, or on behalf of, the Licensor for the purpose of developing and
+              refining the Work, but excluding communication that is conspicuously
+              marked or designated in writing by the copyright owner as "Not a
+              Contribution."
+        
+              "Contributor" shall mean Licensor and any Legal Entity on behalf of
+              whom a Contribution has been received by the Licensor and included
+              within the Work.
+        
+           2. Grant of Copyright License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              copyright license to reproduce, prepare Derivative Works of,
+              publicly display, publicly perform, sublicense, and distribute the
+              Work and such Derivative Works in Source or Object form.
+        
+           3. Grant of Patent License. Subject to the terms and conditions of
+              this License, each Contributor hereby grants to You a perpetual,
+              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+              (except as stated in this section) patent license to make, have made,
+              use, offer to sell, sell, import, and otherwise transfer the Work,
+              where such license applies only to those patent contributions
+              Licensable by such Contributor that are necessarily infringed by
+              their Contribution(s) alone or by the combination of their
+              Contribution(s) with the Work to which such Contribution(s) was
+              submitted. If You institute patent litigation against any entity
+              (including a cross-claim or counterclaim in a lawsuit) alleging that
+              the Work or any Contribution embodied within the Work constitutes
+              direct or contributory patent infringement, then any patent licenses
+              granted to You under this License for that Work shall terminate as
+              of the date such litigation is filed.
+        
+           4. Redistribution. You may reproduce and distribute copies of the
+              Work or Derivative Works thereof in any medium, with or without
+              modifications, and in Source or Object form, provided that You
+              meet the following conditions:
+        
+              (a) You must give any other recipients of the Work or Derivative
+                  Works a copy of this License; and
+        
+              (b) You must cause any modified files to carry prominent notices
+                  stating that You changed the files; and
+        
+              (c) You must retain, in the Source form of any Derivative Works
+                  that You distribute, all copyright, patent, trademark, and
+                  attribution notices from the Source form of the Work,
+                  excluding those notices that do not pertain to any part of
+                  the Derivative Works; and
+        
+              (d) If the Work includes a "NOTICE" text file as part of its
+                  distribution, You must include a readable copy of the
+                  attribution notices contained within such NOTICE file, in
+                  at least one of the following places: within a NOTICE text
+                  file distributed as part of the Derivative Works; within
+                  the Source form or documentation, if provided along with the
+                  Derivative Works; or, within a display generated by the
+                  Derivative Works, if and wherever such third-party notices
+                  normally appear. The contents of the NOTICE file are for
+                  informational purposes only and do not modify the License.
+                  You may add Your own attribution notices within Derivative
+                  Works that You distribute, alongside or in addition to the
+                  NOTICE text from the Work, provided that such additional
+                  attribution notices cannot be construed as modifying the License.
+        
+              You may add Your own license statement for Your modifications and
+              may provide additional grant of rights to use, copy, modify, merge,
+              publish, distribute, sublicense, and/or sell copies of the Work.
+        
+           5. Submission of Contributions. Unless You explicitly state otherwise,
+              any Contribution intentionally submitted for inclusion in the Work
+              by You to the Licensor shall be under the terms and conditions of
+              this License, without any additional terms or conditions.
+              Notwithstanding the above, nothing herein shall supersede or modify
+              the terms of any separate license agreement you may have executed
+              with Licensor regarding such Contributions.
+        
+           6. Trademarks. This License does not grant permission to use the trade
+              names, trademarks, service marks, or product names of the Licensor,
+              except as required for reasonable and customary use in describing the
+              origin of the Work and reproducing the content of the NOTICE file.
+        
+           7. Disclaimer of Warranty. Unless required by applicable law or
+              agreed to in writing, Licensor provides the Work (and each
+              Contributor provides its Contributions) on an "AS IS" BASIS,
+              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+              implied, including, without limitation, any warranties or conditions
+              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+              PARTICULAR PURPOSE. You are solely responsible for determining the
+              appropriateness of using or reproducing the Work and assume any
+              risks associated with Your exercise of permissions under this License.
+        
+           8. Limitation of Liability. In no event and under no legal theory,
+              whether in tort (including negligence), contract, or otherwise,
+              unless required by applicable law (such as deliberate and grossly
+              negligent acts) or agreed to in writing, shall any Contributor be
+              liable to You for damages, including any direct, indirect, special,
+              incidental, or exemplary damages of any character arising as a
+              result of this License or out of the use or inability to use the
+              Work (including but not limited to damages for loss of goodwill,
+              work stoppage, computer failure or malfunction, or all other
+              commercial damages or losses), even if such Contributor has been
+              advised of the possibility of such damages.
+        
+           9. Accepting Warranty or Liability. While redistributing the Work or
+              Derivative Works thereof, You may choose to offer, and charge a fee
+              for, acceptance of support, warranty, indemnity, or other liability
+              obligations and/or rights consistent with this License. However, in
+              accepting such obligations, You may offer only conditions that
+              You alone are responsible for, and not on behalf of any other
+              Contributor.
+        
+           END OF TERMS AND CONDITIONS
+        
+           Copyright 2026 Killian KOPP
+        
+           Licensed under the Apache License, Version 2.0 (the "License");
+           you may not use this file except in compliance with the License.
+           You may obtain a copy of the License at
+        
+               http://www.apache.org/licenses/LICENSE-2.0
+        
+           Unless required by applicable law or agreed to in writing, software
+           distributed under the License is distributed on an "AS IS" BASIS,
+           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+           See the License for the specific language governing permissions and
+           limitations under the License.
+        
+License-File: LICENSE
+Keywords: arclith,cli,ddd,hexagonal-architecture,scaffold
+Requires-Python: >=3.13
+Requires-Dist: arclith>=0.7.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.15.0

arclith_cli-0.7.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+arclith_cli/__init__.py,sha256=IjL9_z1zvhHQzn_1nA_rVf-X3ZpSBJICvdOa6-dRorA,23
+arclith_cli/adapter_templates.py,sha256=9sWKjnhDoBDKja-26Jlmpmp5yaJac5yZoug9y71aVdU,6535
+arclith_cli/add_adapter.py,sha256=nBXlW2uXxZ1Vfe6VsaMGsa6RpJWK2GEBvsKXxrDXkBc,11509
+arclith_cli/entity_scanner.py,sha256=Zeq6UmVjfVrlUJCoiGSzzl2TLmYl9T6PuqCKapByvLU,2033
+arclith_cli/export_config.py,sha256=sl2xl4aiyjJIm9eZR1DoFNpBZl2bg6tMJ2jZp54-O-g,2513
+arclith_cli/main.py,sha256=ApmUjTjxe0BmX1IpZ88rR_pTS3ecLLcwODmgZMPwlNk,7141
+arclith_cli/rename.py,sha256=JK379M4XXyYzbzUBKrmxSbelXpOl-7uPjrEUoEEKCrE,5545
+arclith_cli/scaffold.py,sha256=gmN7aLEpqpCKeCpsYNDynD87jxLb-gxKxsHDsFa6_Y0,2099
+arclith_cli/updater.py,sha256=R5MYlOkmfAk-LgjH1FsANWFQpnOIiZ5XPsmuo8A8m0w,1022
+arclith_cli-0.7.1.dist-info/METADATA,sha256=1Xo_C23YM9IfZp6x9nrVJh1QPtp11YZcbIiyk1kvjK4,11770
+arclith_cli-0.7.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+arclith_cli-0.7.1.dist-info/entry_points.txt,sha256=pE4QclsDOtfvGsOXqo8pJTX6KR5RBwgkmx7GjTGO22Q,53
+arclith_cli-0.7.1.dist-info/licenses/LICENSE,sha256=7IxeTKTBGYEHZK09nS5neiX9qnFGjmD0ssUg2eApX9c,9924
+arclith_cli-0.7.1.dist-info/RECORD,,

arclith_cli-0.7.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

arclith_cli-0.7.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+arclith-cli = arclith_cli.main:app