vega-framework 0.1.14__tar.gz → 0.1.16__tar.gz

{vega_framework-0.1.14 → vega_framework-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vega-framework
-Version: 0.1.14
+Version: 0.1.16
 Summary: Enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications.
 License: MIT
 License-File: LICENSE
@@ -36,6 +36,7 @@ An enterprise-ready Python framework that enforces Clean Architecture for buildi
 
 - ✅ **Automatic Dependency Injection** - Zero boilerplate, type-safe DI
 - ✅ **Clean Architecture Patterns** - Interactor, Mediator, Repository, Service
+- ✅ **Async/Await Support** - Full async support for CLI and web
 - ✅ **Scope Management** - Singleton, Scoped, Transient lifetimes
 - ✅ **Type-Safe** - Full type hints support
 - ✅ **Framework-Agnostic** - Works with any domain (web, AI, IoT, fintech, etc.)
@@ -92,6 +93,8 @@ vega generate mediator <Name>
 vega generate router <Name>          # Requires FastAPI
 vega generate middleware <Name>      # Requires FastAPI
 vega generate model <Name>           # Requires SQLAlchemy
+vega generate command <Name>         # CLI command (async by default)
+vega generate command <Name> --impl sync  # Synchronous CLI command
 ```
 
 ### Add Features
@@ -136,6 +139,45 @@ vega doctor [--path .]
 
 Validates project structure, DI configuration, and architecture compliance.
 
+## Async CLI Commands
+
+Vega provides seamless async/await support in CLI commands, allowing you to execute interactors directly.
+
+### Generate a CLI Command
+
+```bash
+# Generate an async command (default)
+vega generate command CreateUser
+
+# Generate a synchronous command
+vega generate command ListUsers --impl sync
+```
+
+The generator will prompt you for:
+- Command description
+- Options and arguments
+- Whether it will use interactors
+
+### Manual Command Example
+
+```python
+import click
+from vega.cli.utils import async_command
+
+@click.command()
+@click.option('--name', required=True)
+@async_command
+async def create_user(name: str):
+    """Create a user using an interactor"""
+    import config  # Initialize DI container
+    from domain.interactors.create_user import CreateUser
+
+    user = await CreateUser(name=name)
+    click.echo(f"Created: {user.name}")
+```
+
+This enables the same async business logic to work in both CLI and web (FastAPI) contexts.
+
 ## Use Cases
 
 Perfect for:

{vega_framework-0.1.14 → vega_framework-0.1.16}/README.md

@@ -6,6 +6,7 @@ An enterprise-ready Python framework that enforces Clean Architecture for buildi
 
 - ✅ **Automatic Dependency Injection** - Zero boilerplate, type-safe DI
 - ✅ **Clean Architecture Patterns** - Interactor, Mediator, Repository, Service
+- ✅ **Async/Await Support** - Full async support for CLI and web
 - ✅ **Scope Management** - Singleton, Scoped, Transient lifetimes
 - ✅ **Type-Safe** - Full type hints support
 - ✅ **Framework-Agnostic** - Works with any domain (web, AI, IoT, fintech, etc.)
@@ -62,6 +63,8 @@ vega generate mediator <Name>
 vega generate router <Name>          # Requires FastAPI
 vega generate middleware <Name>      # Requires FastAPI
 vega generate model <Name>           # Requires SQLAlchemy
+vega generate command <Name>         # CLI command (async by default)
+vega generate command <Name> --impl sync  # Synchronous CLI command
 ```
 
 ### Add Features
@@ -106,6 +109,45 @@ vega doctor [--path .]
 
 Validates project structure, DI configuration, and architecture compliance.
 
+## Async CLI Commands
+
+Vega provides seamless async/await support in CLI commands, allowing you to execute interactors directly.
+
+### Generate a CLI Command
+
+```bash
+# Generate an async command (default)
+vega generate command CreateUser
+
+# Generate a synchronous command
+vega generate command ListUsers --impl sync
+```
+
+The generator will prompt you for:
+- Command description
+- Options and arguments
+- Whether it will use interactors
+
+### Manual Command Example
+
+```python
+import click
+from vega.cli.utils import async_command
+
+@click.command()
+@click.option('--name', required=True)
+@async_command
+async def create_user(name: str):
+    """Create a user using an interactor"""
+    import config  # Initialize DI container
+    from domain.interactors.create_user import CreateUser
+
+    user = await CreateUser(name=name)
+    click.echo(f"Created: {user.name}")
+```
+
+This enables the same async business logic to work in both CLI and web (FastAPI) contexts.
+
 ## Use Cases
 
 Perfect for:

{vega_framework-0.1.14 → vega_framework-0.1.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vega-framework"
-version = "0.1.14"
+version = "0.1.16"
 description = "Enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications."
 authors = ["Roberto Ferro"]
 license = "MIT"

vega_framework-0.1.16/vega/cli/__init__.py

@@ -0,0 +1,11 @@
+"""Vega Framework CLI tools"""
+
+# Lazy import to avoid circular dependencies when importing utilities
+def __getattr__(name: str):
+    if name == "cli":
+        from vega.cli.main import cli
+        return cli
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = ["cli"]

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/commands/generate.py

@@ -14,6 +14,8 @@ from vega.cli.templates import (
     render_fastapi_router,
     render_fastapi_middleware,
     render_sqlalchemy_model,
+    render_cli_command,
+    render_cli_command_simple,
 )
 from vega.cli.scaffolds import create_fastapi_scaffold
 
@@ -124,6 +126,8 @@ def generate_component(
         _generate_middleware(project_root, project_name, class_name, file_name)
     elif component_type == 'model':
         _generate_sqlalchemy_model(project_root, project_name, class_name, file_name)
+    elif component_type == 'command':
+        _generate_command(project_root, project_name, name, implementation)
 
 
 def _generate_entity(project_root: Path, project_name: str, class_name: str, file_name: str):
@@ -670,3 +674,137 @@ from infrastructure.models.{file_name} import {class_name}Model  # noqa: F401
         click.echo(click.style(f'''
 from infrastructure.models.{file_name} import {class_name}Model  # noqa: F401
 ''', fg='cyan'))
+
+
+def _generate_command(project_root: Path, project_name: str, name: str, is_async: str | None = None) -> None:
+    """Generate a CLI command"""
+    
+    # Check if presentation/cli exists
+    cli_path = project_root / "presentation" / "cli"
+    if not cli_path.exists():
+        cli_path.mkdir(parents=True, exist_ok=True)
+        click.echo(f"+ Created {click.style(str(cli_path.relative_to(project_root)), fg='green')}")
+    
+    # Create commands directory if it doesn't exist
+    commands_path = cli_path / "commands"
+    commands_path.mkdir(exist_ok=True)
+    
+    # Check if __init__.py exists
+    init_file = commands_path / "__init__.py"
+    if not init_file.exists():
+        init_file.write_text('"""CLI Commands"""\n')
+        click.echo(f"+ Created {click.style(str(init_file.relative_to(project_root)), fg='green')}")
+    
+    # Convert name to snake_case for command and file
+    command_name = to_snake_case(name).replace('_', '-')
+    file_name = to_snake_case(name)
+    
+    # Generate command file
+    command_file = commands_path / f"{file_name}.py"
+    
+    if command_file.exists():
+        click.echo(click.style(f"ERROR: Error: {command_file.relative_to(project_root)} already exists", fg='red'))
+        return
+    
+    # Determine if async (default is async unless explicitly set to 'sync' or 'simple')
+    use_async = is_async not in ['sync', 'simple', 'false', 'no'] if is_async else True
+    
+    # Prompt for command details
+    description = click.prompt("Command description", default=f"{name} command")
+    
+    # Ask if user wants to add options/arguments
+    add_params = click.confirm("Add options or arguments?", default=False)
+    
+    options = []
+    arguments = []
+    params_list = []
+    
+    if add_params:
+        click.echo("\nAdd options (e.g., --name, --email). Press Enter when done.")
+        while True:
+            opt_name = click.prompt("Option name (without --)", default="", show_default=False)
+            if not opt_name:
+                break
+            opt_type = click.prompt("Type", default="str", type=click.Choice(['str', 'int', 'bool']))
+            opt_required = click.confirm("Required?", default=False)
+            opt_help = click.prompt("Help text", default=f"{opt_name.replace('-', ' ').replace('_', ' ')}")
+            
+            params_list.append(opt_name.replace('-', '_'))
+            
+            opt_params = f"help='{opt_help}'"
+            if opt_required:
+                opt_params += ", required=True"
+            if opt_type != 'str':
+                if opt_type == 'bool':
+                    opt_params += ", is_flag=True"
+                else:
+                    opt_params += f", type={opt_type}"
+            
+            options.append({
+                "flag": f"--{opt_name}",
+                "params": opt_params
+            })
+        
+        click.echo("\nAdd arguments (positional). Press Enter when done.")
+        while True:
+            arg_name = click.prompt("Argument name", default="", show_default=False)
+            if not arg_name:
+                break
+            arg_required = click.confirm("Required?", default=True)
+            
+            params_list.append(arg_name)
+            
+            arg_params = "" if arg_required else ", required=False"
+            arguments.append({
+                "name": arg_name,
+                "params": arg_params
+            })
+    
+    params_signature = ", ".join(params_list) if params_list else ""
+    
+    # Ask about interactor usage
+    with_interactor = False
+    interactor_name = ""
+    if use_async:
+        with_interactor = click.confirm("Will this command use an interactor?", default=True)
+        if with_interactor:
+            interactor_name = click.prompt("Interactor name", default=f"{to_pascal_case(name)}")
+    
+    usage_example = f"python main.py {command_name}"
+    if params_list:
+        usage_example += " " + " ".join([f"--{p.replace('_', '-')}=value" if f"--{p.replace('_', '-')}" in str(options) else p for p in params_list])
+    
+    # Generate content
+    if use_async:
+        content = render_cli_command(
+            command_name=file_name,
+            description=description,
+            options=options,
+            arguments=arguments,
+            params_signature=params_signature,
+            params_list=params_list,
+            with_interactor=with_interactor,
+            usage_example=usage_example,
+            interactor_name=interactor_name,
+        )
+    else:
+        content = render_cli_command_simple(
+            command_name=file_name,
+            description=description,
+            options=options,
+            arguments=arguments,
+            params_signature=params_signature,
+            params_list=params_list,
+        )
+    
+    command_file.write_text(content)
+    click.echo(f"+ Created {click.style(str(command_file.relative_to(project_root)), fg='green')}")
+    
+    # Instructions for next steps
+    click.echo(f"\nNext steps:")
+    click.echo(f"   1. Implement your command logic in {command_file.relative_to(project_root)}")
+    click.echo(f"   2. Import and register in main.py:")
+    click.echo(click.style(f"      from presentation.cli.commands.{file_name} import {file_name}", fg='cyan'))
+    click.echo(click.style(f"      cli.add_command({file_name})", fg='cyan'))
+    if with_interactor:
+        click.echo(f"   3. Create interactor: vega generate interactor {interactor_name}")

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/commands/migrate.py

@@ -107,9 +107,9 @@ def history():
 @migrate.command()
 def init():
     """Initialize database with current schema (create tables)"""
-    import asyncio
     from pathlib import Path
     import sys
+    from vega.cli.utils import async_command
 
     # Add project root to path to allow imports
     project_root = Path.cwd()
@@ -123,13 +123,14 @@ def init():
         click.echo("Make sure you have SQLAlchemy configured in your project")
         sys.exit(1)
 
+    @async_command
     async def _init():
         click.echo("Creating database tables...")
         await db_manager.create_tables()
         click.secho("Database tables created successfully", fg='green')
 
     try:
-        asyncio.run(_init())
+        _init()
     except Exception as e:
         click.secho(f"Failed to initialize database: {e}", fg='red')
         sys.exit(1)

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/main.py

@@ -56,11 +56,11 @@ def init(project_name, template, path):
 
 @cli.command()
 @click.argument('component_type', type=click.Choice([
-    'entity', 'repository', 'repo', 'service', 'interactor', 'mediator', 'router', 'middleware', 'model'
+    'entity', 'repository', 'repo', 'service', 'interactor', 'mediator', 'router', 'middleware', 'model', 'command'
 ]))
 @click.argument('name')
 @click.option('--path', default='.', help='Project root path')
-@click.option('--impl', default=None, help='Generate infrastructure implementation for repository/service (e.g., memory, sql)')
+@click.option('--impl', default=None, help='Generate infrastructure implementation for repository/service (e.g., memory, sql) or command type (async, sync)')
 def generate(component_type, name, path, impl):
     """
     Generate a component in your Vega project.
@@ -75,6 +75,7 @@ def generate(component_type, name, path, impl):
         router      - FastAPI router (requires web module)
         middleware  - FastAPI middleware (requires web module)
         model       - SQLAlchemy model (requires sqlalchemy module)
+        command     - CLI command (async by default)
 
     Examples:
         vega generate entity Product
@@ -85,6 +86,8 @@ def generate(component_type, name, path, impl):
         vega generate router Product
         vega generate middleware Logging
         vega generate model User
+        vega generate command CreateUser
+        vega generate command ListUsers --impl sync
     """
     # Normalize 'repo' to 'repository'
     if component_type == 'repo':

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/templates/__init__.py

@@ -24,6 +24,8 @@ from .components import (
     render_alembic_env,
     render_alembic_script_mako,
     render_sqlalchemy_model,
+    render_cli_command,
+    render_cli_command_simple,
 )
 from .loader import render_template
 
@@ -53,5 +55,7 @@ __all__ = [
     "render_alembic_env",
     "render_alembic_script_mako",
     "render_sqlalchemy_model",
+    "render_cli_command",
+    "render_cli_command_simple",
     "render_template",
 ]

vega_framework-0.1.16/vega/cli/templates/cli/command.py.j2

@@ -0,0 +1,40 @@
+"""{{ description }}"""
+import click
+from vega.cli.utils import async_command
+import config  # noqa: F401 - Initialize DI container
+
+{% if with_interactor -%}
+# Import your interactors here
+# from domain.interactors.{{ interactor_name }} import {{ interactor_name }}
+{% endif %}
+
+@click.command()
+{%- for option in options %}
+@click.option('{{ option.flag }}', {{ option.params }})
+{%- endfor %}
+{%- for argument in arguments %}
+@click.argument('{{ argument.name }}'{{ argument.params }})
+{%- endfor %}
+@async_command
+async def {{ command_name }}({{ params_signature }}):
+    """
+    {{ description }}
+
+    {% if usage_example -%}
+    Usage:
+        {{ usage_example }}
+    {% endif -%}
+    """
+    {% if with_interactor -%}
+    # Example: Execute an interactor
+    # result = await MyInteractor(param=value)
+    # click.echo(f"Result: {result}")
+    {% endif -%}
+
+    # Your command implementation here
+    click.echo("{{ command_name }} executed!")
+    {% if params_signature -%}
+    {% for param in params_list -%}
+    click.echo(f"  {{ param }}: {{'{'}}{{ param }}{{'}'}}")
+    {% endfor -%}
+    {% endif %}

vega_framework-0.1.16/vega/cli/templates/cli/command_simple.py.j2

@@ -0,0 +1,19 @@
+"""{{ description }}"""
+import click
+
+
+@click.command()
+{%- for option in options %}
+@click.option('{{ option.flag }}', {{ option.params }})
+{%- endfor %}
+{%- for argument in arguments %}
+@click.argument('{{ argument.name }}'{{ argument.params }})
+{%- endfor %}
+def {{ command_name }}({{ params_signature }}):
+    """{{ description }}"""
+    click.echo("{{ command_name }} executed!")
+    {% if params_signature -%}
+    {% for param in params_list -%}
+    click.echo(f"  {{ param }}: {{'{'}}{{ param }}{{'}'}}")
+    {% endfor -%}
+    {% endif %}

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/templates/components.py

@@ -189,3 +189,51 @@ def render_sqlalchemy_model(class_name: str, table_name: str) -> str:
         class_name=class_name,
         table_name=table_name,
     )
+
+
+def render_cli_command(
+    command_name: str,
+    description: str,
+    options: list[dict],
+    arguments: list[dict],
+    params_signature: str,
+    params_list: list[str],
+    with_interactor: bool = True,
+    usage_example: str = "",
+    interactor_name: str = "",
+) -> str:
+    """Return the template for a CLI command"""
+    return render_template(
+        "command.py.j2",
+        subfolder="cli",
+        command_name=command_name,
+        description=description,
+        options=options,
+        arguments=arguments,
+        params_signature=params_signature,
+        params_list=params_list,
+        with_interactor=with_interactor,
+        usage_example=usage_example,
+        interactor_name=interactor_name,
+    )
+
+
+def render_cli_command_simple(
+    command_name: str,
+    description: str,
+    options: list[dict],
+    arguments: list[dict],
+    params_signature: str,
+    params_list: list[str],
+) -> str:
+    """Return the template for a simple CLI command (non-async)"""
+    return render_template(
+        "command_simple.py.j2",
+        subfolder="cli",
+        command_name=command_name,
+        description=description,
+        options=options,
+        arguments=arguments,
+        params_signature=params_signature,
+        params_list=params_list,
+    )

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/templates/project/ARCHITECTURE.md.j2

@@ -507,7 +507,47 @@ class PriceCalculator:
     pass
 ```
 
-### 6. Testing
+### 6. Async CLI Commands
+
+Vega provides the `@async_command` decorator to use async/await in Click CLI commands, allowing you to execute interactors seamlessly:
+
+```python
+import click
+from vega.cli.utils import async_command
+
+@click.command()
+@click.option('--name', required=True)
+@click.option('--email', required=True)
+@async_command
+async def create_user(name: str, email: str):
+    """Create a new user via CLI"""
+    # Import config to initialize DI container
+    import config  # noqa: F401
+    from domain.interactors.create_user import CreateUser
+
+    # Execute async interactor
+    user = await CreateUser(name=name, email=email)
+    click.echo(f"Created user: {user.id} - {user.name}")
+```
+
+**Benefits:**
+- Execute async interactors directly in CLI commands
+- Same business logic works in both CLI and Web (FastAPI) contexts
+- Clean async/await syntax
+- Automatic asyncio event loop management
+
+**Alternative short syntax:**
+```python
+from vega.cli.utils import coro  # Alias for async_command
+
+@click.command()
+@coro
+async def my_command():
+    result = await MyInteractor()
+    click.echo(result)
+```
+
+### 7. Testing
 
 Vega's architecture makes testing straightforward:
 

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/templates/project/README.md.j2

@@ -54,6 +54,28 @@ vega generate interactor CreateUser
 poetry run pytest
 ```
 
+## Using Async Commands
+
+Vega Framework supports async/await in CLI commands, allowing you to execute interactors seamlessly:
+
+```python
+import click
+from vega.cli.utils import async_command
+
+@click.command()
+@click.option('--name', required=True)
+@async_command
+async def create_user(name: str):
+    """Create a user using an interactor"""
+    import config  # Initialize DI container
+    from domain.interactors.create_user import CreateUser
+
+    user = await CreateUser(name=name)
+    click.echo(f"Created: {user.name}")
+```
+
+This allows the same async business logic to work in both CLI and web contexts (FastAPI).
+
 ## Vega Framework
 
 This project uses [Vega Framework](https://github.com/your-org/vega-framework) for Clean Architecture:

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/templates/project/config.py.j2

@@ -10,6 +10,8 @@ from vega.di import Container, set_container
 # from {{ project_name }}.infrastructure.repositories.memory_user_repository import MemoryUserRepository
 
 # Uncomment and configure database manager if using SQLAlchemy
+
+# from settings import settings
 # from infrastructure.database_manager import DatabaseManager
 # db_manager = DatabaseManager(url=settings.database_url)
 

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/templates/project/main_fastapi.py.j2

@@ -1,7 +1,11 @@
 """Main entry point for {{ project_name }}"""
 import click
+from vega.cli.utils import async_command
 import config  # noqa: F401 - Import to initialize DI container
 
+# Import your use cases here
+# from domain.interactors.create_user import CreateUser
+
 
 @click.group()
 def cli():
@@ -34,6 +38,30 @@ def hello():
     click.echo("Add your CLI commands in presentation/cli/commands/")
 
 
+@cli.command()
+@click.option('--name', required=True, help='User name')
+@click.option('--email', required=True, help='User email')
+@async_command
+async def create_user(name: str, email: str):
+    """
+    Example async CLI command that uses an interactor.
+
+    This demonstrates how to use async/await with Click commands
+    to execute interactors and other async operations.
+
+    Usage:
+        python main.py create-user --name="John Doe" --email="john@example.com"
+    """
+    # Import your interactor
+    # from domain.interactors.create_user import CreateUser
+    # user = await CreateUser(name=name, email=email)
+    # click.echo(f"Created user: {user.id} - {user.name}")
+
+    # Placeholder implementation
+    click.echo(f"Creating user: {name} ({email})")
+    click.echo("Note: Replace this with your actual CreateUser interactor")
+
+
 # Add more CLI commands here or import them from presentation/cli/commands/
 
 

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/templates/project/main_standard.py.j2

@@ -1,6 +1,6 @@
 """Main entry point for {{ project_name }}"""
-import asyncio
 import click
+from vega.cli.utils import async_command
 import config  # noqa: F401 - Import to initialize DI container
 
 # Import your use cases here
@@ -27,6 +27,30 @@ def greet(name: str):
     click.echo(f"Hello, {name}!")
 
 
+@cli.command()
+@click.option('--name', required=True, help='User name')
+@click.option('--email', required=True, help='User email')
+@async_command
+async def create_user(name: str, email: str):
+    """
+    Example async command that uses an interactor.
+
+    This demonstrates how to use async/await with Click commands
+    to execute interactors and other async operations.
+
+    Usage:
+        python main.py create-user --name="John Doe" --email="john@example.com"
+    """
+    # Import your interactor
+    # from domain.interactors.create_user import CreateUser
+    # user = await CreateUser(name=name, email=email)
+    # click.echo(f"Created user: {user.id} - {user.name}")
+
+    # Placeholder implementation
+    click.echo(f"Creating user: {name} ({email})")
+    click.echo("Note: Replace this with your actual CreateUser interactor")
+
+
 # Uncomment this block if you enable FastAPI support
 # @cli.command()
 # @click.option('--host', default='0.0.0.0', help='Host to bind')

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/templates/sqlalchemy/env.py.j2

@@ -7,7 +7,7 @@ from alembic import context
 
 # Import your Base and models
 from infrastructure.database_manager import Base
-from config import settings
+from settings import settings
 
 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.
@@ -30,7 +30,7 @@ target_metadata = Base.metadata
 
 def get_url():
     """Get database URL, converting async drivers to sync for Alembic"""
-    url = settings.DATABASE_URL
+    url = settings.database_url
     # Convert async SQLite driver to sync for Alembic
     return url.replace("sqlite+aiosqlite:", "sqlite:")
 

{vega_framework-0.1.14 → vega_framework-0.1.16}/vega/cli/utils/__init__.py

@@ -2,10 +2,13 @@
 from .naming import NamingConverter
 from .messages import CLIMessages
 from .validators import validate_project_name, validate_path_exists
+from .async_support import async_command, coro
 
 __all__ = [
     "NamingConverter",
     "CLIMessages",
     "validate_project_name",
     "validate_path_exists",
+    "async_command",
+    "coro",
 ]

vega_framework-0.1.16/vega/cli/utils/async_support.py

@@ -0,0 +1,55 @@
+"""Async support utilities for Click CLI commands"""
+import asyncio
+import functools
+from typing import TypeVar, Callable, Any
+
+import click
+
+F = TypeVar('F', bound=Callable[..., Any])
+
+
+def async_command(f: F) -> F:
+    """
+    Decorator to make Click commands support async functions.
+
+    This allows you to define async Click commands that can call
+    async interactors and other async operations.
+
+    Example:
+        @click.command()
+        @click.option('--name', required=True)
+        @async_command
+        async def create_user(name: str):
+            # Import config to initialize DI container
+            import config  # noqa: F401
+            from domain.interactors.create_user import CreateUser
+
+            user = await CreateUser(name=name)
+            click.echo(f"Created user: {user.name}")
+
+    Usage in Click groups:
+        @cli.command()
+        @click.argument('user_id')
+        @async_command
+        async def get_user(user_id: str):
+            user = await GetUser(user_id=user_id)
+            click.echo(f"User: {user.name}")
+    """
+    @functools.wraps(f)
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        return asyncio.run(f(*args, **kwargs))
+    return wrapper  # type: ignore
+
+
+def coro(f: F) -> F:
+    """
+    Alias for async_command. Shorter name for convenience.
+
+    Example:
+        @click.command()
+        @coro
+        async def my_command():
+            result = await MyInteractor()
+            click.echo(result)
+    """
+    return async_command(f)

vega_framework-0.1.14/vega/cli/__init__.py

@@ -1,5 +0,0 @@
-"""Vega Framework CLI tools"""
-
-from vega.cli.main import cli
-
-__all__ = ["cli"]