austial-cli 0.1.5__tar.gz → 0.2.1__tar.gz

{austial_cli-0.1.5 → austial_cli-0.2.1}/.gitignore

@@ -9,3 +9,7 @@ htmlcov/
 dist/
 build/
 *.egg-info/
+.DS_Store
+
+.claude/settings.local.json
+coverage.xml

{austial_cli-0.1.5 → austial_cli-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: austial-cli
-Version: 0.1.5
+Version: 0.2.1
 Summary: The `austial` scaffolding CLI (new/generate) and its Jinja2 project templates -- mirrors the separate @nestjs/cli repo.
 Requires-Python: >=3.11
 Requires-Dist: jinja2>=3.1.0

{austial_cli-0.1.5 → austial_cli-0.2.1}/src/austial/cli/generators/__init__.py

@@ -1,10 +1,16 @@
+from austial.cli.generators.component_gen import COMPONENT_KINDS, generate_component
 from austial.cli.generators.controller_gen import generate_controller
 from austial.cli.generators.module_gen import generate_module
 from austial.cli.generators.new_project import create_new_project
 from austial.cli.generators.resource_gen import generate_resource
 from austial.cli.generators.service_gen import generate_service
+from austial.cli.generators.workspace_gen import generate_app, generate_library
 
 __all__ = [
+    "COMPONENT_KINDS",
+    "generate_app",
+    "generate_component",
+    "generate_library",
     "create_new_project",
     "generate_controller",
     "generate_module",

austial_cli-0.2.1/src/austial/cli/generators/agent_files.py

@@ -0,0 +1,45 @@
+"""AI-tool instruction files for a new project.
+
+One canonical ``AGENTS.md`` is written, and every other tool's instructions
+file is a symlink to it, so there is a single file to edit and no drift. Where
+the filesystem can't create symlinks (Windows without Developer Mode), the
+file is copied instead. See https://docs.austial.com/ai/setup.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+AGENTS_FILE = "AGENTS.md"
+
+# link path (relative to the project root) -> symlink target (relative to the link's own directory)
+AGENT_LINKS: dict[str, str] = {
+    "CLAUDE.md": "AGENTS.md",
+    "GEMINI.md": "AGENTS.md",
+    "CONVENTIONS.md": "AGENTS.md",
+    ".windsurfrules": "AGENTS.md",
+    ".clinerules": "AGENTS.md",
+    ".rules": "AGENTS.md",
+    ".github/copilot-instructions.md": "../AGENTS.md",
+}
+
+
+def link_agent_files(project_dir: Path) -> list[str]:
+    """Points every tool-specific instructions file at ``AGENTS.md``. Returns
+    the link paths that had to be copied because symlinks aren't available.
+    Existing files are left untouched."""
+    source = project_dir / AGENTS_FILE
+    copied: list[str] = []
+    for link, target in AGENT_LINKS.items():
+        path = project_dir / link
+        if path.exists() or path.is_symlink():
+            continue
+        path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            os.symlink(target, path)
+        except (OSError, NotImplementedError):
+            shutil.copyfile(source, path)
+            copied.append(link)
+    return copied

{austial_cli-0.1.5 → austial_cli-0.2.1}/src/austial/cli/generators/base.py

@@ -3,6 +3,9 @@ discovery, mirroring what the ``nest`` CLI's schematics engine does."""
 
 from __future__ import annotations
 
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
 from pathlib import Path
 from typing import Any
 
@@ -23,12 +26,36 @@ def render(template_relpath: str, **context: Any) -> str:
     return template.render(**context)
 
 
+_dry_run: ContextVar[list[Path] | None] = ContextVar("austial_dry_run", default=None)
+
+
+@contextmanager
+def dry_run() -> Iterator[list[Path]]:
+    """Inside the block nothing is written; the paths that *would* be created are collected instead
+    (``austial generate ... --dry-run``)."""
+    created: list[Path] = []
+    token = _dry_run.set(created)
+    try:
+        yield created
+    finally:
+        _dry_run.reset(token)
+
+
+def is_dry_run() -> bool:
+    return _dry_run.get() is not None
+
+
 def write_file(path: Path, content: str, *, force: bool = False) -> bool:
     """Writes `content` to `path`, creating parent directories as needed.
     Returns False (and leaves the file untouched) if it already exists and
     `force` wasn't given -- mirrors `nest g`'s "already exists" guard."""
     if path.exists() and not force:
         return False
+    collector = _dry_run.get()
+    if collector is not None:
+        if path.name != "__init__.py":  # package markers are noise in the report
+            collector.append(path)
+        return True
     path.parent.mkdir(parents=True, exist_ok=True)
     path.write_text(content)
     return True

austial_cli-0.2.1/src/austial/cli/generators/component_gen.py

@@ -0,0 +1,55 @@
+"""``austial generate guard|pipe|interceptor|filter|middleware|decorator|class <name>`` -- mirrors the
+same ``nest g`` schematics.
+
+``<name>`` may carry a path: ``auth/api-key`` creates ``src/modules/auth/api_key/api_key_guard.py``
+(``--flat`` drops the innermost folder: ``src/modules/auth/api_key_guard.py``).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from austial.cli.generators.base import find_project_root, render, write_file
+from austial.cli.naming import to_kebab_case, to_pascal_case, to_snake_case
+
+# kind -> (template, file suffix)
+COMPONENT_KINDS: dict[str, tuple[str, str]] = {
+    "guard": ("guard/guard.py.j2", "guard"),
+    "pipe": ("pipe/pipe.py.j2", "pipe"),
+    "interceptor": ("interceptor/interceptor.py.j2", "interceptor"),
+    "filter": ("filter/filter.py.j2", "filter"),
+    "middleware": ("middleware/middleware.py.j2", "middleware"),
+    "decorator": ("decorator/decorator.py.j2", "decorator"),
+    "class": ("class/class.py.j2", ""),
+}
+
+
+def generate_component(kind: str, name: str, *, flat: bool = False, project_root: Path | None = None) -> Path:
+    template, suffix = COMPONENT_KINDS[kind]
+    root = project_root or find_project_root()
+
+    *folders, leaf = [part for part in name.replace("\\", "/").split("/") if part]
+    snake_name = to_snake_case(leaf)
+    class_name = to_pascal_case(leaf)
+    ctx = {
+        "snake_name": snake_name,
+        "class_name": class_name,
+        "kebab_name": to_kebab_case(leaf),
+        "constant_name": snake_name.upper(),
+    }
+
+    base = root / "src" / "modules"
+    directory = base.joinpath(*(to_snake_case(f) for f in folders))
+    if not flat:
+        directory = directory / snake_name
+
+    # Every folder between src/modules and the file is a package.
+    for folder in (directory, *directory.parents):
+        if folder == base.parent or folder == base.parent.parent:
+            break
+        write_file(folder / "__init__.py", "")
+
+    file_name = f"{snake_name}_{suffix}.py" if suffix else f"{snake_name}.py"
+    file_path = directory / file_name
+    write_file(file_path, render(template, **ctx))
+    return file_path

{austial_cli-0.1.5 → austial_cli-0.2.1}/src/austial/cli/generators/module_gen.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from pathlib import Path
 
 from austial.cli.generators.app_module_patcher import register_module
-from austial.cli.generators.base import find_project_root, render, write_file
+from austial.cli.generators.base import find_project_root, is_dry_run, render, write_file
 from austial.cli.naming import to_kebab_case, to_pascal_case, to_snake_case
 
 
@@ -21,7 +21,7 @@ def generate_module(name: str, *, project_root: Path | None = None) -> Path:
     write_file(file_path, render("module/module.py.j2", **ctx))
 
     app_module_path = root / "src" / "app_module.py"
-    if app_module_path.exists():
+    if app_module_path.exists() and not is_dry_run():
         register_module(
             app_module_path,
             f"{class_name}Module",

{austial_cli-0.1.5 → austial_cli-0.2.1}/src/austial/cli/generators/new_project.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import subprocess
 from pathlib import Path
 
+from austial.cli.generators.agent_files import link_agent_files
 from austial.cli.generators.base import render, write_file
 from austial.cli.naming import to_kebab_case
 
@@ -16,10 +17,16 @@ def create_new_project(
     austial_source_path: str | None = None,
     skip_install: bool = False,
     skip_git: bool = False,
+    skip_agents: bool = False,
 ) -> Path:
     project_dir = (directory or Path.cwd() / name).resolve()
     project_slug = to_kebab_case(name)
-    ctx = {"project_name": name, "project_slug": project_slug, "austial_source_path": austial_source_path}
+    ctx = {
+        "project_name": name,
+        "project_slug": project_slug,
+        "austial_source_path": austial_source_path,
+        "agents": not skip_agents,
+    }
 
     write_file(project_dir / "pyproject.toml", render("project/pyproject.toml.j2", **ctx))
     write_file(project_dir / "README.md", render("project/readme.j2", **ctx))
@@ -27,6 +34,10 @@ def create_new_project(
     write_file(project_dir / ".gitignore", render("project/gitignore.j2", **ctx))
     write_file(project_dir / ".pre-commit-config.yaml", render("project/pre_commit_config.yaml.j2", **ctx))
 
+    if not skip_agents:
+        write_file(project_dir / "AGENTS.md", render("project/agents_md.j2", **ctx))
+        link_agent_files(project_dir)
+
     write_file(project_dir / "src" / "__init__.py", "")
     write_file(project_dir / "src" / "main.py", render("project/main.py.j2", **ctx))
     write_file(project_dir / "src" / "app_module.py", render("project/app_module.py.j2", **ctx))

{austial_cli-0.1.5 → austial_cli-0.2.1}/src/austial/cli/generators/resource_gen.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 from pathlib import Path
 
 from austial.cli.generators.app_module_patcher import register_module
-from austial.cli.generators.base import find_project_root, render, write_file
+from austial.cli.generators.base import find_project_root, is_dry_run, render, write_file
 from austial.cli.naming import to_kebab_case, to_pascal_case, to_snake_case
 
 
@@ -30,7 +30,7 @@ def generate_resource(name: str, *, project_root: Path | None = None) -> Path:
     write_file(module_dir / f"{snake_name}_module.py", render("resource/module.py.j2", **ctx))
 
     app_module_path = root / "src" / "app_module.py"
-    if app_module_path.exists():
+    if app_module_path.exists() and not is_dry_run():
         register_module(
             app_module_path,
             f"{class_name}Module",

austial_cli-0.2.1/src/austial/cli/generators/workspace_gen.py

@@ -0,0 +1,42 @@
+"""``austial generate library|app <name>`` -- mirrors Nest's monorepo ``libraries`` and ``applications``.
+
+* ``library`` -> ``libs/<name>/`` : a module + service other apps import (``from libs.<name>... import``).
+* ``app``     -> ``apps/<name>/`` : an additional application with its own ``main.py``, next to ``src/``.
+
+Both live at the project root, which ``austial serve`` and pytest already have on the import path.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from austial.cli.generators.base import find_project_root, render, write_file
+from austial.cli.naming import to_kebab_case, to_pascal_case, to_snake_case
+
+
+def _context(name: str) -> dict[str, str]:
+    return {"snake_name": to_snake_case(name), "class_name": to_pascal_case(name), "kebab_name": to_kebab_case(name)}
+
+
+def generate_library(name: str, *, project_root: Path | None = None) -> Path:
+    root = project_root or find_project_root()
+    ctx = _context(name)
+    folder = root / "libs" / ctx["snake_name"]
+    write_file(root / "libs" / "__init__.py", "")
+    write_file(folder / "__init__.py", "")
+    write_file(folder / f"{ctx['snake_name']}_service.py", render("library/service.py.j2", **ctx))
+    path = folder / f"{ctx['snake_name']}_module.py"
+    write_file(path, render("library/module.py.j2", **ctx))
+    return path
+
+
+def generate_app(name: str, *, project_root: Path | None = None) -> Path:
+    root = project_root or find_project_root()
+    ctx = _context(name)
+    folder = root / "apps" / ctx["snake_name"]
+    write_file(root / "apps" / "__init__.py", "")
+    write_file(folder / "__init__.py", "")
+    write_file(folder / "app_module.py", render("app/app_module.py.j2", **ctx))
+    path = folder / "main.py"
+    write_file(path, render("app/main.py.j2", **ctx))
+    return path

austial_cli-0.2.1/src/austial/cli/main.py

@@ -0,0 +1,317 @@
+"""``austial`` -- the CLI, mirrors the ``nest`` command.
+
+austial new my-app
+austial generate module cats      (alias: austial g module cats)
+austial generate controller cats
+austial generate service cats
+austial generate resource cats
+austial generate guard auth/api-key [--flat] [--dry-run]
+   (also: pipe, interceptor, filter, middleware, decorator, class)
+austial info
+austial serve
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from austial.cli.generators import (
+    COMPONENT_KINDS,
+    create_new_project,
+    generate_app,
+    generate_component,
+    generate_controller,
+    generate_library,
+    generate_module,
+    generate_resource,
+    generate_service,
+)
+from austial.cli.generators.base import ProjectNotFoundError, dry_run, find_project_root
+
+console = Console()
+app = typer.Typer(
+    name="austial",
+    help="Austial CLI -- scaffold and run NestJS-style Python projects, built on FastAPI.",
+    add_completion=False,
+    no_args_is_help=True,
+)
+
+_SCHEMATICS = {
+    "module": generate_module,
+    "controller": generate_controller,
+    "service": generate_service,
+    "provider": generate_service,  # Nest calls a service a "provider"; same schematic
+    "resource": generate_resource,
+    "library": generate_library,
+    "app": generate_app,
+}
+
+# Schematics that accept `--flat` (the ones that create a single file rather than a feature folder).
+_FLAT_SCHEMATICS = set(COMPONENT_KINDS)
+
+# `nest g` short aliases.
+_ALIASES = {
+    "mo": "module",
+    "co": "controller",
+    "s": "service",
+    "pr": "provider",
+    "r": "resource",
+    "gu": "guard",
+    "pi": "pipe",
+    "in": "interceptor",
+    "f": "filter",
+    "mi": "middleware",
+    "d": "decorator",
+    "cl": "class",
+    "lib": "library",
+}
+
+_ALL_SCHEMATICS = sorted({*_SCHEMATICS, *COMPONENT_KINDS})
+_SCHEMATIC_HELP = "One of: " + ", ".join(_ALL_SCHEMATICS) + " (or a short alias: " + ", ".join(sorted(_ALIASES)) + ")"
+
+
+@app.command("new")
+def new_project(
+    name: str = typer.Argument(..., help="Name of the new project/directory to create."),
+    directory: str | None = typer.Option(None, "--directory", "-d", help="Target directory (defaults to ./<name>)."),
+    skip_install: bool = typer.Option(False, "--skip-install", help="Don't run `uv sync` after scaffolding."),
+    skip_git: bool = typer.Option(False, "--skip-git", help="Don't run `git init` after scaffolding."),
+    skip_agents: bool = typer.Option(
+        False,
+        "--skip-agents",
+        help="Don't write AGENTS.md or the per-tool symlinks (CLAUDE.md, GEMINI.md, ...).",
+    ),
+    link: str | None = typer.Option(
+        None,
+        "--link",
+        help="Path to a local Austial framework checkout to depend on via `uv`'s editable path sources "
+        "(useful before the framework is published to PyPI).",
+    ),
+) -> None:
+    """Scaffold a brand-new Austial project -- mirrors `nest new <name>`."""
+    console.print(f"[bold green]CREATE[/bold green] {name}/ ...")
+    target = Path(directory).resolve() if directory else None
+    project_dir = create_new_project(
+        name,
+        directory=target,
+        austial_source_path=link,
+        skip_install=skip_install,
+        skip_git=skip_git,
+        skip_agents=skip_agents,
+    )
+    console.print(f"[bold green]\u2714[/bold green] Project created at [bold]{project_dir}[/bold]")
+    console.print("\nNext steps:")
+    console.print(f"  cd {project_dir.name}")
+    if skip_install:
+        console.print("  uv sync")
+    console.print("  cp .env.example .env")
+    console.print("  uv run austial serve\n")
+
+
+def _generate(schematic: str, name: str, *, flat: bool = False, dry: bool = False) -> None:
+    schematic = _ALIASES.get(schematic.lower(), schematic.lower())
+    if schematic not in _ALL_SCHEMATICS:
+        console.print(
+            f"[bold red]Unknown schematic[/bold red] '{schematic}'. Choose one of: {', '.join(_ALL_SCHEMATICS)}."
+        )
+        raise typer.Exit(code=1)
+    if flat and schematic not in _FLAT_SCHEMATICS:
+        console.print(f"[bold red]\u2716[/bold red] --flat applies to: {', '.join(sorted(_FLAT_SCHEMATICS))}.")
+        raise typer.Exit(code=1)
+
+    def run() -> Path:
+        if schematic in COMPONENT_KINDS:
+            return generate_component(schematic, name, flat=flat)
+        return _SCHEMATICS[schematic](name)
+
+    try:
+        if dry:
+            with dry_run() as created:
+                run()
+            for path in created:
+                console.print(f"[bold yellow]CREATE[/bold yellow] {path} [dim](dry run)[/dim]")
+            console.print("[dim]Dry run: nothing was written.[/dim]")
+            return
+        path = run()
+    except ProjectNotFoundError as exc:
+        console.print(f"[bold red]\u2716[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+    console.print(f"[bold green]CREATE[/bold green] {path}")
+
+
+_FLAT_HELP = "Don't create a folder for the file (guard, pipe, interceptor, filter, middleware, decorator, class)."
+_DRY_HELP = "Show what would be created without writing anything."
+
+
+@app.command("generate")
+def generate(
+    schematic: str = typer.Argument(..., help=_SCHEMATIC_HELP),
+    name: str = typer.Argument(..., help="Name, optionally with a path: 'cats' or 'auth/api-key'."),
+    flat: bool = typer.Option(False, "--flat", help=_FLAT_HELP),
+    dry: bool = typer.Option(False, "--dry-run", "-d", help=_DRY_HELP),
+) -> None:
+    """Generate an artifact -- mirrors `nest generate`."""
+    _generate(schematic, name, flat=flat, dry=dry)
+
+
+@app.command("g", hidden=True)
+def generate_alias(
+    schematic: str = typer.Argument(..., help=_SCHEMATIC_HELP),
+    name: str = typer.Argument(..., help="Name, optionally with a path: 'cats' or 'auth/api-key'."),
+    flat: bool = typer.Option(False, "--flat", help=_FLAT_HELP),
+    dry: bool = typer.Option(False, "--dry-run", "-d", help=_DRY_HELP),
+) -> None:
+    """Alias for `generate` -- mirrors Nest CLI's `nest g`."""
+    _generate(schematic, name, flat=flat, dry=dry)
+
+
+@app.command("info")
+def info() -> None:
+    """Prints Python, platform and installed Austial package versions -- mirrors `nest info`."""
+    import importlib.metadata as metadata
+    import platform
+
+    console.print(f"[bold]Python[/bold]    {platform.python_version()} ({platform.system()} {platform.machine()})")
+    packages = sorted(
+        (dist.metadata["Name"], dist.version)
+        for dist in metadata.distributions()
+        if (dist.metadata["Name"] or "").lower().startswith("austial")
+    )
+    console.print("[bold]Austial packages[/bold]")
+    for name, version in packages:
+        console.print(f"  {name:<22} {version}")
+    try:
+        console.print(f"[bold]Project[/bold]   {find_project_root()}")
+    except ProjectNotFoundError:
+        console.print("[bold]Project[/bold]   [dim](not inside an Austial project)[/dim]")
+
+
+def _project_root_or_exit() -> Path:
+    try:
+        return find_project_root()
+    except ProjectNotFoundError as exc:
+        console.print(f"[bold red]\u2716[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+
+@app.command("serve")
+def serve(
+    host: str = typer.Option("0.0.0.0", help="Bind host."),
+    port: int = typer.Option(8000, help="Bind port."),
+    reload: bool = typer.Option(True, help="Auto-reload on file changes (dev mode)."),
+) -> None:
+    """Runs the current project with auto-reload (mirrors `nest start --watch`)."""
+    _serve(host, port, reload)
+
+
+@app.command("start")
+def start(
+    host: str = typer.Option("0.0.0.0", help="Bind host."),
+    port: int = typer.Option(8000, help="Bind port."),
+    watch: bool = typer.Option(False, "--watch", "-w", help="Auto-reload on file changes."),
+    target: str = typer.Option("src.main:app", "--app", help="ASGI app to run, e.g. apps.admin.main:app."),
+) -> None:
+    """Runs the project (mirrors `nest start`; add --watch for reload, --app for an app in apps/)."""
+    _serve(host, port, watch, target)
+
+
+@app.command("build")
+def build() -> None:
+    """Byte-compiles the project (src, libs, apps) and checks the module graph imports and scans cleanly."""
+    from austial.cli.tools import TargetError, build_project, load_target, module_graph_for
+
+    root = _project_root_or_exit()
+    failed = build_project(root)
+    if failed:
+        console.print(f"[bold red]\u2716[/bold red] Compilation failed in: {', '.join(failed)}")
+        raise typer.Exit(code=1)
+    try:
+        graph = module_graph_for(load_target("src.app_module:AppModule", root))
+    except TargetError as exc:
+        console.print(f"[bold red]\u2716[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+    console.print(f"[bold green]\u2714[/bold green] Build OK: {len(graph.records)} modules scanned")
+
+
+@app.command("add")
+def add(
+    package: str = typer.Argument(..., help="Optional package, e.g. cache, events, websockets (see `austial add x`)."),
+    dry: bool = typer.Option(False, "--dry-run", "-d", help="Print the command without running it."),
+) -> None:
+    """Installs an optional Austial package into the project with uv (mirrors `nest add`)."""
+    import subprocess
+
+    from austial.cli.tools import TargetError, add_command
+
+    try:
+        command = add_command(package)
+    except TargetError as exc:
+        console.print(f"[bold red]\u2716[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+    console.print(f"[bold]$ {' '.join(command)}[/bold]")
+    if dry:
+        return
+    raise typer.Exit(code=subprocess.run(command, cwd=_project_root_or_exit()).returncode)
+
+
+@app.command("graph")
+def graph(
+    target: str = typer.Argument("src.app_module:AppModule", help="module.path:RootModule"),
+    fmt: str = typer.Option("mermaid", "--format", "-f", help="mermaid or json."),
+) -> None:
+    """Prints the module graph (imports, providers, controllers, exports), like Nest's devtools graph."""
+    import json
+
+    from austial.cli.tools import TargetError, load_target, module_graph_for
+
+    try:
+        module_graph = module_graph_for(load_target(target, _project_root_or_exit()))
+    except TargetError as exc:
+        console.print(f"[bold red]\u2716[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+    typer.echo(json.dumps(module_graph.to_dict(), indent=2) if fmt == "json" else module_graph.to_mermaid())
+
+
+@app.command("repl")
+def repl(target: str = typer.Argument("src.app_module:AppModule", help="module.path:RootModule")) -> None:
+    """Starts a Python REPL with the app booted: get(Token), run(coroutine). Mirrors Nest's REPL."""
+    import code
+
+    from austial.cli.tools import ReplSession, TargetError, load_target
+
+    try:
+        session = ReplSession(load_target(target, _project_root_or_exit()))
+    except TargetError as exc:
+        console.print(f"[bold red]\u2716[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+    try:
+        code.interact(banner=session.banner(), local=session.namespace)
+    finally:
+        session.close()
+
+
+def _serve(host: str, port: int, reload: bool, target: str = "src.main:app") -> None:
+    import uvicorn
+
+    try:
+        project_root = find_project_root()
+    except ProjectNotFoundError as exc:
+        console.print(f"[bold red]\u2716[/bold red] {exc}")
+        raise typer.Exit(code=1) from exc
+
+    import sys
+
+    sys.path.insert(0, str(project_root))
+    console.print(f"[bold green]\u25b6[/bold green] Serving {project_root.name} on http://{host}:{port}")
+    uvicorn.run(target, host=host, port=port, reload=reload, app_dir=str(project_root))
+
+
+def run() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    run()

austial_cli-0.2.1/src/austial/cli/templates/app/app_module.py.j2

@@ -0,0 +1,6 @@
+from austial import Module
+
+
+@Module(imports=[], controllers=[], providers=[])
+class {{ class_name }}AppModule:
+    pass

austial_cli-0.2.1/src/austial/cli/templates/app/main.py.j2

@@ -0,0 +1,7 @@
+"""Entry point of the `{{ snake_name }}` app: `uvicorn apps.{{ snake_name }}.main:app` (from the repository root)."""
+
+from austial import AustialFactory
+
+from apps.{{ snake_name }}.app_module import {{ class_name }}AppModule
+
+app = AustialFactory.create({{ class_name }}AppModule, title="{{ class_name }}")

austial_cli-0.2.1/src/austial/cli/templates/class/class.py.j2

@@ -0,0 +1,2 @@
+class {{ class_name }}:
+    pass

austial_cli-0.2.1/src/austial/cli/templates/decorator/decorator.py.j2

@@ -0,0 +1,11 @@
+from austial.core.metadata import set_metadata
+
+{{ constant_name }}_KEY = "{{ snake_name }}"
+
+
+def {{ class_name }}(*values: str):
+    """Marks a controller or handler: ``@{{ class_name }}("a", "b")``.
+
+    Read it back with ``Reflector.get({{ constant_name }}_KEY, context.get_handler())`` in a guard or interceptor.
+    """
+    return set_metadata({{ constant_name }}_KEY, list(values))

austial_cli-0.2.1/src/austial/cli/templates/filter/filter.py.j2

@@ -0,0 +1,11 @@
+from austial import ArgumentsHost, Catch, ExceptionFilter, HttpException, Injectable
+from starlette.responses import JSONResponse
+
+
+@Injectable()
+@Catch(HttpException)
+class {{ class_name }}Filter(ExceptionFilter):
+    async def catch(self, exception: HttpException, host: ArgumentsHost) -> JSONResponse:
+        request = host.get_request()
+        body = {**exception.get_response(), "path": request.url.path}
+        return JSONResponse(status_code=exception.get_status(), content=body)

austial_cli-0.2.1/src/austial/cli/templates/guard/guard.py.j2

@@ -0,0 +1,8 @@
+from austial import CanActivate, ExecutionContext, Injectable
+
+
+@Injectable()
+class {{ class_name }}Guard(CanActivate):
+    async def can_activate(self, context: ExecutionContext) -> bool:
+        request = context.get_request()  # noqa: F841 - inspect headers, state, etc.
+        return True