vega-framework 0.1.16__py3-none-any.whl → 0.1.18__py3-none-any.whl

vega/cli/templates/cli/command.py.j2

@@ -9,12 +9,12 @@ import config  # noqa: F401 - Initialize DI container
 {% endif %}
 
 @click.command()
-{%- for option in options %}
+{% for option in options %}
 @click.option('{{ option.flag }}', {{ option.params }})
-{%- endfor %}
-{%- for argument in arguments %}
+{% endfor %}
+{% for argument in arguments %}
 @click.argument('{{ argument.name }}'{{ argument.params }})
-{%- endfor %}
+{% endfor %}
 @async_command
 async def {{ command_name }}({{ params_signature }}):
     """

vega/cli/templates/cli/command_simple.py.j2

@@ -3,12 +3,12 @@ import click
 
 
 @click.command()
-{%- for option in options %}
+{% for option in options %}
 @click.option('{{ option.flag }}', {{ option.params }})
-{%- endfor %}
-{%- for argument in arguments %}
+{% endfor %}
+{% for argument in arguments %}
 @click.argument('{{ argument.name }}'{{ argument.params }})
-{%- endfor %}
+{% endfor %}
 def {{ command_name }}({{ params_signature }}):
     """{{ description }}"""
     click.echo("{{ command_name }} executed!")

vega/cli/templates/project/ARCHITECTURE.md.j2

@@ -262,6 +262,232 @@ class StripePaymentService(PaymentService):
         pass
 ```
 
+## Development Workflow with Vega CLI
+
+Vega provides powerful CLI commands to quickly scaffold components following Clean Architecture principles. These commands help you maintain the correct architectural boundaries while accelerating development.
+
+### Generating Domain Layer Components
+
+**Entities** - Pure business objects:
+```bash
+vega generate entity User
+vega generate entity Product
+vega generate entity Order
+```
+
+**Repository Interfaces** - Data persistence abstractions:
+```bash
+vega generate repository UserRepository
+vega generate repository Product  # Auto-adds "Repository" suffix
+```
+
+**Repository with Implementation** - Create both interface and concrete implementation:
+```bash
+vega generate repository User --impl memory   # In-memory implementation
+vega generate repository User --impl sql      # SQL implementation
+vega generate repository User --impl postgres # PostgreSQL implementation
+```
+
+**Service Interfaces** - External service abstractions:
+```bash
+vega generate service EmailService
+vega generate service PaymentService
+```
+
+**Service with Implementation**:
+```bash
+vega generate service Email --impl sendgrid
+vega generate service Payment --impl stripe
+```
+
+**Interactors** - Single-purpose use cases:
+```bash
+vega generate interactor CreateUser
+vega generate interactor GetUserById
+vega generate interactor UpdateUserEmail
+vega generate interactor DeleteUser
+```
+
+### Generating Application Layer Components
+
+**Mediators** - Complex workflows:
+```bash
+vega generate mediator UserRegistrationFlow
+vega generate mediator CheckoutWorkflow
+vega generate mediator OrderProcessingPipeline
+```
+
+### Generating Infrastructure Layer Components
+
+**SQLAlchemy Models** - Database models (requires database support):
+```bash
+vega generate model User
+vega generate model Product
+vega generate model Order
+```
+
+Note: Models are automatically registered in Alembic for migrations.
+
+### Generating Presentation Layer Components
+
+**CLI Commands** - Command-line interfaces:
+```bash
+vega generate command CreateUser              # Async command (default)
+vega generate command ListUsers --impl sync   # Synchronous command
+```
+
+The generator will interactively prompt for:
+- Command description
+- Options and arguments (flags, parameters)
+- Whether to use interactors
+- Parameter types and validation
+
+**FastAPI Routers** - HTTP API endpoints (requires web support):
+```bash
+vega generate router User
+vega generate router Product
+vega generate router Order
+```
+
+**FastAPI Middleware** - Request/response processing (requires web support):
+```bash
+vega generate middleware Logging
+vega generate middleware Authentication
+vega generate middleware RateLimiting
+```
+
+### Adding Features to Existing Projects
+
+**Add FastAPI Web Support**:
+```bash
+vega add web
+```
+
+Creates complete FastAPI scaffold:
+- `presentation/web/` directory structure
+- Routes and middleware setup
+- Health check endpoints
+- App factory pattern
+
+**Add Database Support**:
+```bash
+vega add sqlalchemy  # or: vega add db
+```
+
+Adds complete database infrastructure:
+- SQLAlchemy async support
+- Alembic migrations
+- Database manager
+- Base model classes
+
+### Database Migrations Workflow
+
+After adding SQLAlchemy support, manage your database schema:
+
+```bash
+# Initialize database (creates tables)
+vega migrate init
+
+# Create migration after model changes
+vega migrate create -m "Add users table"
+vega migrate create -m "Add email_verified field to users"
+
+# Apply pending migrations
+vega migrate upgrade
+
+# Rollback last migration
+vega migrate downgrade
+
+# Check current migration status
+vega migrate current
+
+# View migration history
+vega migrate history
+```
+
+### Project Validation
+
+Validate your project structure and architecture compliance:
+
+```bash
+vega doctor
+vega doctor --path ./my-project
+```
+
+Checks for:
+- Correct folder structure
+- DI container configuration
+- Import dependencies
+- Architecture violations (e.g., domain depending on infrastructure)
+
+### Development Best Practices with CLI
+
+**1. Start with Domain Layer**:
+```bash
+# Define your entities first
+vega generate entity User
+
+# Create repository interfaces
+vega generate repository UserRepository
+
+# Implement use cases
+vega generate interactor CreateUser
+vega generate interactor GetUserById
+```
+
+**2. Add Infrastructure Implementations**:
+```bash
+# Generate repository implementation
+vega generate repository User --impl memory  # Start with in-memory
+
+# Later, add database support
+vega add sqlalchemy
+vega generate model User
+vega generate repository User --impl sql
+```
+
+**3. Build Application Workflows**:
+```bash
+# Orchestrate multiple use cases
+vega generate mediator UserRegistrationFlow
+```
+
+**4. Create Delivery Mechanisms**:
+```bash
+# CLI interface
+vega generate command create-user
+
+# Web API (add web first if not present)
+vega add web
+vega generate router User
+```
+
+**5. Validate Architecture**:
+```bash
+# Ensure clean architecture compliance
+vega doctor
+```
+
+### CLI Quick Reference
+
+| Command | Purpose |
+|---------|---------|
+| `vega init <name>` | Create new Vega project |
+| `vega generate entity <Name>` | Generate domain entity |
+| `vega generate repository <Name>` | Generate repository interface |
+| `vega generate interactor <Name>` | Generate use case |
+| `vega generate mediator <Name>` | Generate workflow |
+| `vega generate command <Name>` | Generate CLI command |
+| `vega generate router <Name>` | Generate FastAPI router |
+| `vega generate model <Name>` | Generate SQLAlchemy model |
+| `vega add web` | Add FastAPI support |
+| `vega add sqlalchemy` | Add database support |
+| `vega migrate <command>` | Manage database migrations |
+| `vega doctor` | Validate project architecture |
+| `vega update` | Update Vega Framework |
+
+For complete documentation, see the [README](README.md#cli-commands).
+
 ## Dependency Injection
 
 Vega provides automatic dependency injection through decorators and a container.

vega/cli/templates/project/README.md.j2

@@ -20,15 +20,11 @@ Vega Framework application with Clean Architecture.
 │   └── services/        # Service implementations
 │
 ├── presentation/        # Delivery mechanisms
-{% if template == "fastapi" -%}
-│   ├── web/            # FastAPI web interface
+│   ├── web/            # FastAPI web interface (if added)
 │   │   ├── routes/     # HTTP endpoints
 │   │   ├── app.py      # FastAPI app factory
 │   │   └── main.py     # ASGI entrypoint
-│   └── cli/            # CLI commands (if needed)
-{% else -%}
 │   └── cli/            # CLI commands
-{% endif -%}
 │
 ├── config.py            # Dependency injection setup
 ├── settings.py          # Application configuration
@@ -45,15 +41,85 @@ poetry install
 cp .env.example .env
 # Edit .env with your configuration
 
-# Generate components
-vega generate entity User
-vega generate repository UserRepository
-vega generate interactor CreateUser
+# Run CLI commands
+python main.py hello
+python main.py greet --name John
+
+# If using FastAPI template, run the web server
+python main.py web
+python main.py web --reload  # With auto-reload
+# Visit http://localhost:8000/api/health/status
 
 # Run tests
 poetry run pytest
 ```
 
+## Development with Vega CLI
+
+### Generate Components
+
+Generate Clean Architecture components quickly:
+
+```bash
+# Domain layer
+vega generate entity Product
+vega generate repository ProductRepository --impl memory
+vega generate service EmailService
+vega generate interactor CreateProduct
+
+# Application layer
+vega generate mediator CheckoutFlow
+
+# Presentation layer (web)
+vega generate router Product
+vega generate middleware Logging
+
+# Presentation layer (CLI)
+vega generate command CreateUser
+vega generate command ListUsers --impl sync
+```
+
+### Add Features
+
+Add FastAPI web support to your project:
+
+```bash
+vega add web
+```
+
+### Add Database Support
+
+Add SQLAlchemy and Alembic for database management:
+
+```bash
+vega add sqlalchemy  # or: vega add db
+```
+
+Then manage your database:
+
+```bash
+# Initialize database
+vega migrate init
+
+# Create migrations
+vega migrate create -m "Add users table"
+
+# Apply migrations
+vega migrate upgrade
+
+# Rollback migrations
+vega migrate downgrade
+```
+
+### Generate Database Models
+
+After adding SQLAlchemy support:
+
+```bash
+vega generate model User
+vega generate model Product
+```
+
 ## Using Async Commands
 
 Vega Framework supports async/await in CLI commands, allowing you to execute interactors seamlessly:
@@ -76,16 +142,47 @@ async def create_user(name: str):
 
 This allows the same async business logic to work in both CLI and web contexts (FastAPI).
 
+## Project Commands Quick Reference
+
+```bash
+# Component generation
+vega generate entity <Name>
+vega generate repository <Name> [--impl memory|sql]
+vega generate interactor <Name>
+vega generate mediator <Name>
+vega generate command <Name> [--impl sync]
+
+# Feature management
+vega add web
+vega add sqlalchemy
+
+# Database management (requires SQLAlchemy)
+vega migrate init
+vega migrate create -m "message"
+vega migrate upgrade
+vega migrate downgrade
+
+# Project validation
+vega doctor
+
+# Framework updates
+vega update
+vega update --check
+```
+
 ## Vega Framework
 
-This project uses [Vega Framework](https://github.com/your-org/vega-framework) for Clean Architecture:
+This project uses [Vega Framework](https://github.com/robertosixty1/vega-framework) for Clean Architecture:
 
-- Automatic Dependency Injection
-- Clean Architecture patterns (4 layers: Domain, Application, Infrastructure, Presentation)
-- Type-safe with Python type hints
-- Easy to test and maintain
+- ✅ Automatic Dependency Injection
+- ✅ Clean Architecture patterns (4 layers: Domain, Application, Infrastructure, Presentation)
+- ✅ Type-safe with Python type hints
+- ✅ Async/await support for CLI and web
+- ✅ Easy to test and maintain
+- ✅ Framework-agnostic business logic
 
 ## Documentation
 
 - [Vega Framework Docs](https://vega-framework.readthedocs.io/)
 - [Clean Architecture](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)
+- [Vega CLI Reference](https://github.com/robertosixty1/vega-framework#cli-commands)

vega_framework-0.1.18.dist-info/METADATA

@@ -0,0 +1,483 @@
+Metadata-Version: 2.4
+Name: vega-framework
+Version: 0.1.18
+Summary: Enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications.
+License: MIT
+License-File: LICENSE
+Keywords: clean-architecture,dependency-injection,framework,python,async,vega
+Author: Roberto Ferro
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: click (>=8.0,<9.0)
+Requires-Dist: jinja2 (>=3.1,<4.0)
+Requires-Dist: pydantic (>=2.0,<3.0)
+Requires-Dist: pydantic-settings (>=2.0,<3.0)
+Requires-Dist: toml (>=0.10,<0.11)
+Project-URL: Documentation, https://vega-framework.readthedocs.io
+Project-URL: Homepage, https://github.com/RobyFerro/vega-framework
+Project-URL: Repository, https://github.com/RobyFerro/vega-framework
+Description-Content-Type: text/markdown
+
+# Vega Framework
+
+An enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications.
+
+## Features
+
+- ✅ **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.)
+- ✅ **CLI Scaffolding** - Generate projects and components instantly
+- ✅ **FastAPI Integration** - Built-in web scaffold with routing and middleware
+- ✅ **SQLAlchemy Support** - Database management with async support and migrations
+- ✅ **Lightweight** - No unnecessary dependencies
+
+## Installation
+
+```bash
+pip install vega-framework
+```
+
+## Quick Start
+
+```bash
+# Create new project
+vega init my-app
+
+# Generate components
+vega generate entity User
+vega generate repository UserRepository
+vega generate interactor CreateUser
+
+# Create FastAPI project
+vega init my-api --template fastapi
+```
+
+## CLI Commands
+
+Vega Framework provides a comprehensive CLI for scaffolding and managing Clean Architecture projects.
+
+### Project Management
+
+#### `vega init` - Initialize New Project
+
+Create a new Vega project with Clean Architecture structure.
+
+```bash
+vega init <project_name> [OPTIONS]
+```
+
+**Options:**
+- `--template <type>` - Project template (default: `basic`)
+  - `basic` - Standard Clean Architecture project with CLI support
+  - `fastapi` - Project with FastAPI web scaffold included
+  - `ai-rag` - AI/RAG application template (coming soon)
+- `--path <directory>` - Parent directory for project (default: current directory)
+
+**Examples:**
+```bash
+vega init my-app
+vega init my-api --template fastapi
+vega init my-ai --template ai-rag --path ./projects
+```
+
+**Creates:**
+- `domain/` - Entities, repositories, services, interactors
+- `application/` - Mediators and workflows
+- `infrastructure/` - Repository and service implementations
+- `presentation/` - CLI and web interfaces
+- `config.py` - DI container configuration
+- `settings.py` - Application settings
+- `pyproject.toml` - Dependencies and project metadata
+
+---
+
+#### `vega doctor` - Validate Project
+
+Validate your Vega project structure and architecture compliance.
+
+```bash
+vega doctor [--path .]
+```
+
+**Options:**
+- `--path <directory>` - Project path to validate (default: current directory)
+
+**Checks:**
+- Correct folder structure
+- DI container configuration
+- Import dependencies
+- Architecture violations
+
+**Example:**
+```bash
+vega doctor
+vega doctor --path ./my-app
+```
+
+---
+
+#### `vega update` - Update Framework
+
+Update Vega Framework to the latest version.
+
+```bash
+vega update [OPTIONS]
+```
+
+**Options:**
+- `--check` - Check for updates without installing
+- `--force` - Force reinstall even if up to date
+
+**Examples:**
+```bash
+vega update              # Update to latest version
+vega update --check      # Check for updates only
+vega update --force      # Force reinstall
+```
+
+---
+
+### Code Generation
+
+#### `vega generate` - Generate Components
+
+Generate Clean Architecture components in your project.
+
+```bash
+vega generate <component_type> <name> [OPTIONS]
+```
+
+**Component Types:**
+
+##### Domain Layer
+
+**`entity`** - Domain Entity (dataclass)
+```bash
+vega generate entity Product
+```
+Creates a domain entity in `domain/entities/`
+
+**`repository`** - Repository Interface
+```bash
+vega generate repository ProductRepository
+vega generate repository Product --impl memory    # With in-memory implementation
+vega generate repository Product --impl sql       # With SQL implementation
+```
+Creates repository interface in `domain/repositories/` and optionally an implementation in `infrastructure/repositories/`
+
+**Alias:** `repo` can be used instead of `repository`
+
+**`service`** - Service Interface
+```bash
+vega generate service EmailService
+vega generate service Email --impl smtp          # With SMTP implementation
+```
+Creates service interface in `domain/services/` and optionally an implementation in `infrastructure/services/`
+
+**`interactor`** - Use Case / Interactor
+```bash
+vega generate interactor CreateProduct
+vega generate interactor GetUserById
+```
+Creates interactor (use case) in `domain/interactors/`
+
+##### Application Layer
+
+**`mediator`** - Workflow / Mediator
+```bash
+vega generate mediator CheckoutFlow
+vega generate mediator OrderProcessing
+```
+Creates mediator (workflow orchestrator) in `application/mediators/`
+
+##### Infrastructure Layer
+
+**`model`** - SQLAlchemy Model *(requires SQLAlchemy)*
+```bash
+vega generate model User
+vega generate model ProductCategory
+```
+Creates SQLAlchemy model in `infrastructure/models/` and registers it in Alembic
+
+##### Presentation Layer
+
+**`router`** - FastAPI Router *(requires FastAPI)*
+```bash
+vega generate router Product
+vega generate router User
+```
+Creates FastAPI router in `presentation/web/routes/` and auto-registers it
+
+**`middleware`** - FastAPI Middleware *(requires FastAPI)*
+```bash
+vega generate middleware Logging
+vega generate middleware Authentication
+```
+Creates FastAPI middleware in `presentation/web/middleware/` and auto-registers it
+
+**`command`** - CLI Command
+```bash
+vega generate command CreateUser                 # Async command (default)
+vega generate command ListUsers --impl sync      # Synchronous command
+```
+Creates CLI command in `presentation/cli/commands/`
+
+The generator will prompt for:
+- Command description
+- Options and arguments
+- Whether it will use interactors
+
+**Options:**
+- `--path <directory>` - Project root path (default: current directory)
+- `--impl <type>` - Generate infrastructure implementation
+  - For `repository`: `memory`, `sql`, or custom name
+  - For `service`: custom implementation name
+  - For `command`: `sync` or `async` (default: async)
+
+**Examples:**
+```bash
+# Domain layer
+vega generate entity Product
+vega generate repository ProductRepository --impl memory
+vega generate service EmailService --impl smtp
+vega generate interactor CreateProduct
+
+# Application layer
+vega generate mediator CheckoutFlow
+
+# Presentation layer (web)
+vega generate router Product
+vega generate middleware Logging
+
+# Presentation layer (CLI)
+vega generate command CreateUser
+vega generate command ListUsers --impl sync
+
+# Infrastructure layer
+vega generate model User
+```
+
+---
+
+### Feature Management
+
+#### `vega add` - Add Features to Project
+
+Add additional features to an existing Vega project.
+
+```bash
+vega add <feature> [OPTIONS]
+```
+
+**Features:**
+
+**`web`** - Add FastAPI Web Scaffold
+```bash
+vega add web
+```
+Adds FastAPI web scaffold to your project:
+- `presentation/web/` - Web application structure
+- `presentation/web/routes/` - API routes
+- `presentation/web/middleware/` - Middleware components
+- `presentation/web/app.py` - FastAPI app factory
+
+**`sqlalchemy` / `db`** - Add SQLAlchemy Database Support
+```bash
+vega add sqlalchemy
+vega add db              # Alias
+```
+Adds SQLAlchemy database support:
+- `infrastructure/database_manager.py` - Database connection manager
+- `infrastructure/models/` - SQLAlchemy models directory
+- `alembic/` - Database migration system
+- `alembic.ini` - Alembic configuration
+
+**Options:**
+- `--path <directory>` - Path to Vega project (default: current directory)
+
+**Examples:**
+```bash
+vega add web
+vega add sqlalchemy
+vega add db --path ./my-project
+```
+
+---
+
+### Database Management
+
+#### `vega migrate` - Database Migration Commands
+
+Manage database schema migrations with Alembic *(requires SQLAlchemy)*.
+
+**`init`** - Initialize Database
+```bash
+vega migrate init
+```
+Creates all database tables based on current models. Use this for initial setup.
+
+**`create`** - Create New Migration
+```bash
+vega migrate create -m "migration message"
+```
+Generates a new migration file by auto-detecting model changes.
+
+**Options:**
+- `-m, --message <text>` - Migration description (required)
+
+**`upgrade`** - Apply Migrations
+```bash
+vega migrate upgrade [--revision head]
+```
+Apply pending migrations to the database.
+
+**Options:**
+- `--revision <id>` - Target revision (default: `head` - latest)
+
+**`downgrade`** - Rollback Migrations
+```bash
+vega migrate downgrade [--revision -1]
+```
+Rollback database migrations.
+
+**Options:**
+- `--revision <id>` - Target revision (default: `-1` - previous)
+
+**`current`** - Show Current Revision
+```bash
+vega migrate current
+```
+Display the current database migration revision.
+
+**`history`** - Show Migration History
+```bash
+vega migrate history
+```
+Display complete migration history with details.
+
+**Examples:**
+```bash
+# Initialize database
+vega migrate init
+
+# Create migration after changing models
+vega migrate create -m "Add user table"
+vega migrate create -m "Add email field to users"
+
+# Apply all pending migrations
+vega migrate upgrade
+
+# Apply migrations up to specific revision
+vega migrate upgrade --revision abc123
+
+# Rollback last migration
+vega migrate downgrade
+
+# Rollback to specific revision
+vega migrate downgrade --revision xyz789
+
+# Check current status
+vega migrate current
+
+# View history
+vega migrate history
+```
+
+---
+
+### Getting Help
+
+**Show Version:**
+```bash
+vega --version
+```
+
+**Show Help:**
+```bash
+vega --help                    # Main help
+vega <command> --help          # Command-specific help
+vega generate --help           # Generate command help
+vega migrate --help            # Migrate command help
+```
+
+**Examples:**
+```bash
+vega init --help
+vega generate --help
+vega add --help
+vega migrate upgrade --help
+```
+
+## 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:
+
+- AI/RAG applications
+- E-commerce platforms
+- Fintech systems
+- Mobile backends
+- Microservices
+- CLI tools
+- Any Python application requiring clean architecture
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions welcome! This framework is extracted from production code and battle-tested.
+

{vega_framework-0.1.16.dist-info → vega_framework-0.1.18.dist-info}/RECORD

@@ -11,8 +11,8 @@ vega/cli/scaffolds/__init__.py,sha256=WFJf2H_4UWL89gDxX8PXKkTVSVOfw7hFfyaPWKokp1
 vega/cli/scaffolds/fastapi.py,sha256=dA1RRWuS2HjCRh5q8T-VEBU8r8C-IqRbNZW_SqTv1Wg,3760
 vega/cli/scaffolds/sqlalchemy.py,sha256=il5JqiA8LSQKnNoOYfAFD82rdYx5l_ZsqsjHnplYohw,6164
 vega/cli/templates/__init__.py,sha256=0-jsxHcM4IbJiiZXqszm1XiYRYVcHgOivXdq7jqxBrk,1720
-vega/cli/templates/cli/command.py.j2,sha256=GwZGWFLQsA64w4Qes2a1mcfB65MlPfSRIJs0QuS4Upk,1112
-vega/cli/templates/cli/command_simple.py.j2,sha256=RviSXTP5mfbMkdT8DcDTO9OZKunYpyacHGs-dw6bDhQ,546
+vega/cli/templates/cli/command.py.j2,sha256=HUVRBHzQJlgqg7IgregDpBJRd-g1t2S0uOgC6wwPtI4,1108
+vega/cli/templates/cli/command_simple.py.j2,sha256=fXxVauGVlzofshenmMlsEfVLI9EAp7SFfPbbF_ayLBQ,542
 vega/cli/templates/components.py,sha256=NvGJqjP2-EYy52YW8xihQOV0FHeWhqUEFKul5qe1XFY,7231
 vega/cli/templates/domain/entity.py.j2,sha256=dl5rzuJMnTRqOdU5SYV2o_OPGy9l6DNf_symCcjdjK0,344
 vega/cli/templates/domain/interactor.py.j2,sha256=Hv6whUyW67smjMRw_HuvC3_-q7g32dEUOFZdmi5xkrc,684
@@ -25,8 +25,8 @@ vega/cli/templates/infrastructure/service_impl.py.j2,sha256=AgP2oqMbbcd0ctVfiVyO
 vega/cli/templates/loader.py,sha256=cyt9ZOVLwBgv4ijPxoqR4JgFSbdkXCMzviHcq3fdv8Q,2712
 vega/cli/templates/project/.env.example,sha256=BqfRxYeOasgZMz4_B2kybu6areIy9dHCt5BJ6fa56ik,221
 vega/cli/templates/project/.gitignore,sha256=7JSDihCtBznd-QxQ4wUtHM9fnbYnbw6PK4Auh56ofAY,229
-vega/cli/templates/project/ARCHITECTURE.md.j2,sha256=4Lb4rTJsPnXM5x_9C5xTS621UP2MnBnjUB5J65bjl9c,17951
-vega/cli/templates/project/README.md.j2,sha256=bVIcPzaLWHFa_MgD5kYss22HUL_19TLVVGrcz9Kngtc,2744
+vega/cli/templates/project/ARCHITECTURE.md.j2,sha256=P7NiaGDp3ekPP3Fn5mtlMUWf66qqAAFtZzcmYRXJKis,23737
+vega/cli/templates/project/README.md.j2,sha256=Oea0AiDb_rm-GPsLFAPhYEpMmtHt_pqCRjrreymZj8Y,4601
 vega/cli/templates/project/config.py.j2,sha256=1Iva9JEz5ej_WmTbRVBvOfSBhYUKIzN88p6GYKR0m4s,866
 vega/cli/templates/project/main.py.j2,sha256=WhV5rm2K_jtXrSorChcgwWN7XraRoXwvfYOcQ852lM0,2387
 vega/cli/templates/project/main_fastapi.py.j2,sha256=BRd91YwFbr4H5mBKYClO8NM2VGODh3xaGLdkfkGskUA,1980
@@ -64,8 +64,8 @@ vega/patterns/repository.py,sha256=uYUyLs-O8OqW1Wb9ZqIo8UUcCjZ5UFuHors_F2iDg9A,1
 vega/patterns/service.py,sha256=buFRgJoeQtZQK22Upb4vh84c1elWKFXWBaB0X4RaruE,1374
 vega/settings/__init__.py,sha256=Eb8PMUyXAlCAQIcL2W8QhTTUHUbVlkAfXdpTUlADo1I,786
 vega/settings/base.py,sha256=bL45hyoa3t-hQOvur860eSo7O833sQMsXJJPwbTVbwE,1321
-vega_framework-0.1.16.dist-info/METADATA,sha256=rOmnUGA7sjOdKJTh7-6lUhGzkVr_kRx0OjoufBH4SpE,5432
-vega_framework-0.1.16.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-vega_framework-0.1.16.dist-info/entry_points.txt,sha256=p3gyTmPYjNRLbuiKS-hG3ytWd-ssBweFy6VZ-F9FTNk,42
-vega_framework-0.1.16.dist-info/licenses/LICENSE,sha256=wlHh1MBTcs2kSQr99P30mZ61s7uh7Cp9Rk0YiJxots0,1084
-vega_framework-0.1.16.dist-info/RECORD,,
+vega_framework-0.1.18.dist-info/METADATA,sha256=fV4NIlBhT5TvAO91i_rWx1gg6mvAX_7vvzII9VSU2m4,12271
+vega_framework-0.1.18.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+vega_framework-0.1.18.dist-info/entry_points.txt,sha256=p3gyTmPYjNRLbuiKS-hG3ytWd-ssBweFy6VZ-F9FTNk,42
+vega_framework-0.1.18.dist-info/licenses/LICENSE,sha256=wlHh1MBTcs2kSQr99P30mZ61s7uh7Cp9Rk0YiJxots0,1084
+vega_framework-0.1.18.dist-info/RECORD,,

vega_framework-0.1.16.dist-info/METADATA

@@ -1,200 +0,0 @@
-Metadata-Version: 2.4
-Name: vega-framework
-Version: 0.1.16
-Summary: Enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications.
-License: MIT
-License-File: LICENSE
-Keywords: clean-architecture,dependency-injection,framework,python,async,vega
-Author: Roberto Ferro
-Requires-Python: >=3.10,<4.0
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: click (>=8.0,<9.0)
-Requires-Dist: jinja2 (>=3.1,<4.0)
-Requires-Dist: pydantic (>=2.0,<3.0)
-Requires-Dist: pydantic-settings (>=2.0,<3.0)
-Requires-Dist: toml (>=0.10,<0.11)
-Project-URL: Documentation, https://vega-framework.readthedocs.io
-Project-URL: Homepage, https://github.com/RobyFerro/vega-framework
-Project-URL: Repository, https://github.com/RobyFerro/vega-framework
-Description-Content-Type: text/markdown
-
-# Vega Framework
-
-An enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications.
-
-## Features
-
-- ✅ **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.)
-- ✅ **CLI Scaffolding** - Generate projects and components instantly
-- ✅ **FastAPI Integration** - Built-in web scaffold with routing and middleware
-- ✅ **SQLAlchemy Support** - Database management with async support and migrations
-- ✅ **Lightweight** - No unnecessary dependencies
-
-## Installation
-
-```bash
-pip install vega-framework
-```
-
-## Quick Start
-
-```bash
-# Create new project
-vega init my-app
-
-# Generate components
-vega generate entity User
-vega generate repository UserRepository
-vega generate interactor CreateUser
-
-# Create FastAPI project
-vega init my-api --template fastapi
-```
-
-## CLI Commands
-
-### Initialize Project
-
-```bash
-vega init <project_name> [--template basic|fastapi|ai-rag] [--path .]
-```
-
-Creates a new Vega project with Clean Architecture structure:
-
-- `domain/` - Entities, repositories, services, interactors
-- `application/` - Mediators and workflows
-- `infrastructure/` - Repository and service implementations
-- `config.py` - DI container setup
-- `settings.py` - Application configuration
-
-### Generate Components
-
-```bash
-vega generate entity <Name>
-vega generate repository <Name> [--impl memory|sql]
-vega generate service <Name>
-vega generate interactor <Name>
-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
-
-```bash
-# Add FastAPI web scaffold
-vega add web
-
-# Add SQLAlchemy database support
-vega add sqlalchemy
-# or
-vega add db
-```
-
-### Database Migrations (SQLAlchemy)
-
-```bash
-# Initialize database
-vega migrate init
-
-# Create a new migration
-vega migrate create -m "migration message"
-
-# Apply migrations
-vega migrate upgrade [--revision head]
-
-# Rollback migrations
-vega migrate downgrade [--revision -1]
-
-# Show current revision
-vega migrate current
-
-# Show migration history
-vega migrate history
-```
-
-### Validate Project
-
-```bash
-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:
-
-- AI/RAG applications
-- E-commerce platforms
-- Fintech systems
-- Mobile backends
-- Microservices
-- CLI tools
-- Any Python application requiring clean architecture
-
-## License
-
-MIT
-
-## Contributing
-
-Contributions welcome! This framework is extracted from production code and battle-tested.
-