elric-cli 1.0.0__py3-none-any.whl

elric_cli/__init__.py

@@ -0,0 +1 @@
+# TODO: Implementazione completa in Fase 5

elric_cli/app.py

@@ -0,0 +1,24 @@
+import typer
+
+from elric_cli.commands import apikey, make, migrate, route, serve
+from elric_cli.commands.project import new_project
+
+app = typer.Typer(
+    name="elric",
+    help="Elric CLI - bootstrap and manage Elric projects",
+    add_completion=False,
+)
+
+# Register command groups
+app.add_typer(make.app, name="make")
+app.add_typer(migrate.app, name="migrate")
+app.add_typer(route.app, name="route")
+app.add_typer(apikey.app, name="apikey")
+
+# Register standalone commands
+app.command()(serve.serve)
+app.command("new")(new_project)
+
+
+if __name__ == "__main__":
+    app()

elric_cli/commands/apikey.py

@@ -0,0 +1,134 @@
+import asyncio
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer(help="API key management commands")
+console = Console()
+
+
+def _missing_project_dependency(error: Exception) -> None:
+    message = (
+        "This command must run inside an Elric application project. "
+        "Use `elric new <name>` to create one, then run this command in that directory."
+    )
+    typer.secho(f"✗ {message}", fg=typer.colors.RED)
+    typer.secho(f"  Details: {error}", fg=typer.colors.YELLOW)
+
+
+@app.command("create")
+def create_apikey(name: str = typer.Argument(..., help="Name for the API key")):
+    """Create a new API key."""
+    async def _create():
+        from app.providers.database import AsyncSessionLocal
+        from app.utils.api_key import create_api_key_record
+
+        async with AsyncSessionLocal() as session:
+            api_key_record, key = await create_api_key_record(name, session)
+            
+            console.print("\n[bold green]✓ API Key created successfully![/bold green]\n")
+            console.print(f"[bold]ID:[/bold]         {api_key_record.id}")
+            console.print(f"[bold]Name:[/bold]       {api_key_record.name}")
+            console.print(f"[bold]Prefix:[/bold]     {api_key_record.prefix}")
+            console.print(f"[bold]Created:[/bold]    {api_key_record.created_at}")
+            console.print(f"[bold]Active:[/bold]     {api_key_record.is_active}\n")
+            console.print(f"[bold yellow]🔑 API Key:[/bold yellow] {key}\n")
+            console.print("[bold red]⚠️  IMPORTANT:[/bold red] Save this key securely!")
+            console.print("   This is the only time you'll see the full key.\n")
+    
+    try:
+        asyncio.run(_create())
+    except ModuleNotFoundError as e:
+        _missing_project_dependency(e)
+        raise typer.Exit(1)
+    except Exception as e:
+        typer.secho(f"✗ Failed to create API key: {e}", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+
+@app.command("list")
+def list_apikeys():
+    """List all API keys."""
+    async def _list():
+        from sqlalchemy import select
+
+        from app.providers.database import AsyncSessionLocal
+        from database.models.api_key import ApiKey
+
+        async with AsyncSessionLocal() as session:
+            result = await session.execute(
+                select(ApiKey).order_by(ApiKey.created_at.desc())
+            )
+            api_keys = result.scalars().all()
+            
+            if not api_keys:
+                console.print("[yellow]No API keys found.[/yellow]")
+                return
+            
+            table = Table(title="API Keys")
+            table.add_column("ID", style="cyan")
+            table.add_column("Name", style="green")
+            table.add_column("Prefix", style="yellow")
+            table.add_column("Active", style="magenta")
+            table.add_column("Created", style="blue")
+            table.add_column("Last Used", style="white")
+            
+            for key in api_keys:
+                table.add_row(
+                    str(key.id)[:8] + "...",
+                    key.name,
+                    key.prefix,
+                    "✓" if key.is_active else "✗",
+                    key.created_at.strftime("%Y-%m-%d %H:%M"),
+                    key.last_used_at.strftime("%Y-%m-%d %H:%M") if key.last_used_at else "-",
+                )
+            
+            console.print(table)
+            console.print(f"\n[bold]Total API keys:[/bold] {len(api_keys)}")
+    
+    try:
+        asyncio.run(_list())
+    except ModuleNotFoundError as e:
+        _missing_project_dependency(e)
+        raise typer.Exit(1)
+    except Exception as e:
+        typer.secho(f"✗ Failed to list API keys: {e}", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+
+@app.command("revoke")
+def revoke_apikey(key_id: str = typer.Argument(..., help="API key ID to revoke")):
+    """Revoke an API key by ID."""
+    async def _revoke():
+        from sqlalchemy import select
+
+        from app.providers.database import AsyncSessionLocal
+        from database.models.api_key import ApiKey
+
+        async with AsyncSessionLocal() as session:
+            result = await session.execute(
+                select(ApiKey).where(ApiKey.id == key_id)
+            )
+            api_key = result.scalar_one_or_none()
+            
+            if not api_key:
+                console.print(f"[red]✗ API key not found: {key_id}[/red]")
+                raise typer.Exit(1)
+            
+            api_key.is_active = False
+            session.add(api_key)
+            await session.commit()
+            
+            console.print(f"[green]✓ API key revoked: {api_key.name}[/green]")
+    
+    try:
+        asyncio.run(_revoke())
+    except typer.Exit:
+        raise
+    except ModuleNotFoundError as e:
+        _missing_project_dependency(e)
+        raise typer.Exit(1)
+    except Exception as e:
+        typer.secho(f"✗ Failed to revoke API key: {e}", fg=typer.colors.RED)
+        raise typer.Exit(1)

elric_cli/commands/make.py

@@ -0,0 +1,266 @@
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from elric_cli.utils import (
+    AGENT_TYPES,
+    DEFAULT_MODEL,
+    get_agent_stub_name,
+    get_available_models,
+    get_llm_config,
+    get_project_root,
+    get_provider_from_model,
+    get_stub_path,
+    get_timestamp,
+    render_template,
+    to_kebab_case,
+    to_pascal_case,
+    to_snake_case,
+    validate_model,
+    write_file,
+)
+
+app = typer.Typer(help="Generate components from stubs")
+
+
+@app.command("agent")
+def make_agent(
+    name: str,
+    type: str = typer.Option("simple", "--type", "-t", help=f"Agent type: {', '.join(AGENT_TYPES.keys())}"),
+    model: str = typer.Option(DEFAULT_MODEL, "--model", "-m", help="LLM model to use"),
+):
+    """Generate a new LangGraph agent with specified type and model."""
+    class_name = to_pascal_case(name)
+    snake_name = to_snake_case(name)
+    
+    # Validate agent type
+    if type not in AGENT_TYPES:
+        typer.secho(f"✗ Invalid agent type: {type}", fg=typer.colors.RED)
+        typer.secho(f"  Available types: {', '.join(AGENT_TYPES.keys())}", fg=typer.colors.YELLOW)
+        raise typer.Exit(1)
+    
+    # Validate model (warn if not in predefined list)
+    if not validate_model(model):
+        typer.secho(f"⚠ Warning: '{model}' is not in the predefined model list", fg=typer.colors.YELLOW)
+        typer.secho(f"  Available models: {', '.join(get_available_models()[:5])}...", fg=typer.colors.YELLOW)
+        typer.secho(f"  Proceeding anyway with auto-detected provider", fg=typer.colors.YELLOW)
+    
+    # Get LLM configuration
+    llm_config = get_llm_config(model)
+    provider = get_provider_from_model(model)
+    
+    # Get the appropriate stub
+    stub_name = get_agent_stub_name(type)
+    
+    context = {
+        "class_name": class_name,
+        "snake_name": snake_name,
+        "kebab_name": to_kebab_case(name),
+        "model_name": model,
+        "llm_import": llm_config["import"],
+        "llm_class": llm_config["class"],
+        "provider": provider,
+    }
+    
+    content = render_template(get_stub_path(stub_name), context)
+    output_path = get_project_root() / "app" / "ai" / "agents" / f"{snake_name}.py"
+    
+    write_file(str(output_path), content)
+    typer.secho(f"✓ Created {type} agent: {output_path}", fg=typer.colors.GREEN)
+    typer.secho(f"  Model: {model} ({provider})", fg=typer.colors.BLUE)
+
+
+@app.command("chain")
+def make_chain(name: str):
+    """Generate a new LangChain chain."""
+    class_name = to_pascal_case(name)
+    snake_name = to_snake_case(name)
+    
+    context = {
+        "class_name": class_name,
+        "snake_name": snake_name,
+        "kebab_name": to_kebab_case(name),
+    }
+    
+    content = render_template(get_stub_path("chain"), context)
+    output_path = get_project_root() / "app" / "ai" / "chains" / f"{snake_name}.py"
+    
+    write_file(str(output_path), content)
+    typer.secho(f"✓ Created chain: {output_path}", fg=typer.colors.GREEN)
+
+
+@app.command("tool")
+def make_tool(name: str):
+    """Generate a new LangChain tool."""
+    class_name = to_pascal_case(name)
+    snake_name = to_snake_case(name)
+    
+    context = {
+        "class_name": class_name,
+        "snake_name": snake_name,
+        "kebab_name": to_kebab_case(name),
+    }
+    
+    content = render_template(get_stub_path("tool"), context)
+    output_path = get_project_root() / "app" / "ai" / "tools" / f"{snake_name}.py"
+    
+    write_file(str(output_path), content)
+    typer.secho(f"✓ Created tool: {output_path}", fg=typer.colors.GREEN)
+
+
+@app.command("route")
+def make_route(name: str):
+    """Generate a new FastAPI router."""
+    class_name = to_pascal_case(name)
+    snake_name = to_snake_case(name)
+    
+    context = {
+        "class_name": class_name,
+        "snake_name": snake_name,
+        "kebab_name": to_kebab_case(name),
+    }
+    
+    content = render_template(get_stub_path("route"), context)
+    output_path = get_project_root() / "app" / "routes" / f"{snake_name}.py"
+    
+    write_file(str(output_path), content)
+    typer.secho(f"✓ Created route: {output_path}", fg=typer.colors.GREEN)
+
+
+@app.command("controller")
+def make_controller(name: str):
+    """Generate a new controller."""
+    class_name = to_pascal_case(name)
+    snake_name = to_snake_case(name)
+    
+    context = {
+        "class_name": class_name,
+        "snake_name": snake_name,
+        "kebab_name": to_kebab_case(name),
+    }
+    
+    content = render_template(get_stub_path("controller"), context)
+    output_path = get_project_root() / "app" / "controllers" / f"{snake_name}.py"
+    
+    write_file(str(output_path), content)
+    typer.secho(f"✓ Created controller: {output_path}", fg=typer.colors.GREEN)
+
+
+@app.command("schema")
+def make_schema(name: str):
+    """Generate a new Pydantic schema."""
+    class_name = to_pascal_case(name)
+    snake_name = to_snake_case(name)
+    
+    context = {
+        "class_name": class_name,
+        "snake_name": snake_name,
+        "kebab_name": to_kebab_case(name),
+    }
+    
+    content = render_template(get_stub_path("schema"), context)
+    output_path = get_project_root() / "app" / "schemas" / f"{snake_name}.py"
+    
+    write_file(str(output_path), content)
+    typer.secho(f"✓ Created schema: {output_path}", fg=typer.colors.GREEN)
+
+
+@app.command("model")
+def make_model(name: str):
+    """Generate a new SQLModel entity."""
+    class_name = to_pascal_case(name)
+    snake_name = to_snake_case(name)
+    
+    context = {
+        "class_name": class_name,
+        "snake_name": snake_name,
+        "kebab_name": to_kebab_case(name),
+    }
+    
+    content = render_template(get_stub_path("model"), context)
+    output_path = get_project_root() / "database" / "models" / f"{snake_name}.py"
+    
+    write_file(str(output_path), content)
+    typer.secho(f"✓ Created model: {output_path}", fg=typer.colors.GREEN)
+
+
+@app.command("migration")
+def make_migration(description: str):
+    """Generate a new Alembic migration."""
+    try:
+        result = subprocess.run(
+            ["alembic", "revision", "--autogenerate", "-m", description],
+            cwd=get_project_root(),
+            capture_output=True,
+            text=True,
+        )
+        
+        if result.returncode == 0:
+            typer.secho(f"✓ Created migration: {description}", fg=typer.colors.GREEN)
+            typer.echo(result.stdout)
+        else:
+            typer.secho(f"✗ Failed to create migration", fg=typer.colors.RED)
+            typer.echo(result.stderr)
+            raise typer.Exit(1)
+    except FileNotFoundError:
+        typer.secho("✗ Alembic not found. Make sure it's installed.", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+
+@app.command("job")
+def make_job(name: str):
+    """Generate a new background job."""
+    class_name = to_pascal_case(name)
+    snake_name = to_snake_case(name)
+    
+    context = {
+        "class_name": class_name,
+        "snake_name": snake_name,
+        "kebab_name": to_kebab_case(name),
+    }
+    
+    content = render_template(get_stub_path("job"), context)
+    output_path = get_project_root() / "app" / "jobs" / f"{snake_name}.py"
+    
+    write_file(str(output_path), content)
+    typer.secho(f"✓ Created job: {output_path}", fg=typer.colors.GREEN)
+
+
+@app.command("exception")
+def make_exception(name: str):
+    """Generate a new custom exception."""
+    class_name = to_pascal_case(name)
+    snake_name = to_snake_case(name)
+    
+    context = {
+        "class_name": class_name,
+        "snake_name": snake_name,
+        "kebab_name": to_kebab_case(name),
+    }
+    
+    content = render_template(get_stub_path("exception"), context)
+    output_path = get_project_root() / "app" / "exceptions" / f"{snake_name}.py"
+    
+    write_file(str(output_path), content)
+    typer.secho(f"✓ Created exception: {output_path}", fg=typer.colors.GREEN)
+
+
+@app.command("test")
+def make_test(name: str):
+    """Generate a new test file."""
+    class_name = to_pascal_case(name)
+    snake_name = to_snake_case(name)
+    
+    context = {
+        "class_name": class_name,
+        "snake_name": snake_name,
+        "kebab_name": to_kebab_case(name),
+    }
+    
+    content = render_template(get_stub_path("test"), context)
+    output_path = get_project_root() / "tests" / "unit" / f"test_{snake_name}.py"
+    
+    write_file(str(output_path), content)
+    typer.secho(f"✓ Created test: {output_path}", fg=typer.colors.GREEN)

elric_cli/commands/migrate.py

@@ -0,0 +1,69 @@
+import subprocess
+
+import typer
+
+from elric_cli.utils import get_project_root
+
+app = typer.Typer(help="Database migration commands")
+
+
+def run_alembic_command(args: list[str]) -> None:
+    """Run an Alembic command."""
+    try:
+        result = subprocess.run(
+            ["alembic"] + args,
+            cwd=get_project_root(),
+            capture_output=True,
+            text=True,
+        )
+        
+        if result.returncode == 0:
+            typer.echo(result.stdout)
+        else:
+            typer.secho(f"✗ Command failed", fg=typer.colors.RED)
+            typer.echo(result.stderr)
+            raise typer.Exit(1)
+    except FileNotFoundError:
+        typer.secho("✗ Alembic not found. Make sure it's installed.", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+
+@app.command()
+def migrate():
+    """Run all pending migrations (alembic upgrade head)."""
+    typer.secho("Running migrations...", fg=typer.colors.BLUE)
+    run_alembic_command(["upgrade", "head"])
+    typer.secho("✓ Migrations completed", fg=typer.colors.GREEN)
+
+
+@app.command("rollback")
+def migrate_rollback():
+    """Rollback the last migration (alembic downgrade -1)."""
+    typer.secho("Rolling back last migration...", fg=typer.colors.BLUE)
+    run_alembic_command(["downgrade", "-1"])
+    typer.secho("✓ Rollback completed", fg=typer.colors.GREEN)
+
+
+@app.command("fresh")
+def migrate_fresh():
+    """Drop all tables and re-run all migrations."""
+    confirm = typer.confirm(
+        "⚠️  This will DROP ALL TABLES and re-run migrations. Continue?",
+        abort=True,
+    )
+    
+    if confirm:
+        typer.secho("Dropping all tables...", fg=typer.colors.BLUE)
+        run_alembic_command(["downgrade", "base"])
+        
+        typer.secho("Running all migrations...", fg=typer.colors.BLUE)
+        run_alembic_command(["upgrade", "head"])
+        
+        typer.secho("✓ Fresh migration completed", fg=typer.colors.GREEN)
+
+
+@app.command("status")
+def migrate_status():
+    """Show current migration status (alembic current)."""
+    typer.secho("Current migration status:", fg=typer.colors.BLUE)
+    run_alembic_command(["current"])

elric_cli/commands/project.py

@@ -0,0 +1,72 @@
+import shutil
+import subprocess
+from pathlib import Path
+
+import typer
+
+DEFAULT_TEMPLATE_REPO = "https://github.com/marcoinsabato/elric-template.git"
+
+
+def new_project(
+    name: str = typer.Argument(..., help="Project name"),
+    directory: Path = typer.Option(Path("."), "--directory", "-d", help="Directory where project will be created"),
+    install: bool = typer.Option(True, "--install/--no-install", help="Run `uv sync` after project creation"),
+    keep_git: bool = typer.Option(False, "--keep-git", help="Keep template .git history"),
+):
+    """Create a new Elric project from a remote template repository."""
+    template_repo = DEFAULT_TEMPLATE_REPO
+
+    target_path = (directory / name).resolve()
+    if target_path.exists() and any(target_path.iterdir()):
+        typer.secho(f"✗ Target directory is not empty: {target_path}", fg=typer.colors.RED)
+        raise typer.Exit(1)
+    if target_path.exists() and not target_path.is_dir():
+        typer.secho(f"✗ Target path is not a directory: {target_path}", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+    clone_command = ["git", "clone", "--depth", "1"]
+    clone_command.extend([template_repo, str(target_path)])
+
+    typer.secho(f"Creating project: {name}", fg=typer.colors.BLUE)
+    typer.secho(f"Template: {template_repo}", fg=typer.colors.BLUE)
+    typer.secho(f"Destination: {target_path}", fg=typer.colors.BLUE)
+
+    try:
+        clone_result = subprocess.run(clone_command, capture_output=True, text=True)
+    except FileNotFoundError:
+        typer.secho("✗ Git not found. Install git and retry.", fg=typer.colors.RED)
+        raise typer.Exit(1)
+
+    if clone_result.returncode != 0:
+        typer.secho("✗ Failed to clone template repository.", fg=typer.colors.RED)
+        if clone_result.stderr:
+            typer.echo(clone_result.stderr.strip())
+        raise typer.Exit(1)
+
+    if not keep_git:
+        git_dir = target_path / ".git"
+        if git_dir.exists() and git_dir.is_dir():
+            shutil.rmtree(git_dir)
+
+    if install:
+        typer.secho("Installing dependencies with uv sync...", fg=typer.colors.BLUE)
+        try:
+            install_result = subprocess.run(["uv", "sync"], cwd=target_path, capture_output=True, text=True)
+        except FileNotFoundError:
+            typer.secho("⚠ uv not found. Skip install and run `uv sync` manually.", fg=typer.colors.YELLOW)
+            install_result = None
+        if install_result and install_result.returncode != 0:
+            typer.secho("⚠ Dependency installation failed. You can run `uv sync` manually.", fg=typer.colors.YELLOW)
+            if install_result.stderr:
+                typer.echo(install_result.stderr.strip())
+
+    typer.secho("✓ Project created successfully!", fg=typer.colors.GREEN)
+    typer.echo("")
+    typer.secho("Next steps:", fg=typer.colors.BLUE)
+    typer.echo(f"  cd {target_path}")
+    if not install:
+        typer.echo("  uv sync")
+    typer.echo("  cp .env.example .env")
+    typer.echo("  docker compose -f docker/docker-compose.yml up -d db redis")
+    typer.echo("  elric migrate")
+    typer.echo("  elric serve")

elric_cli/commands/route.py

@@ -0,0 +1,49 @@
+import typer
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer(help="Route management commands")
+console = Console()
+
+
+@app.command("list")
+def list_routes():
+    """List all registered routes in the FastAPI application."""
+    try:
+        from app import create_app
+        
+        app_instance = create_app()
+        
+        table = Table(title="Registered Routes")
+        table.add_column("Method", style="cyan")
+        table.add_column("Path", style="green")
+        table.add_column("Name", style="yellow")
+        
+        routes = []
+        for route in app_instance.routes:
+            if hasattr(route, "methods"):
+                for method in route.methods:
+                    if method != "HEAD":
+                        routes.append({
+                            "method": method,
+                            "path": route.path,
+                            "name": route.name or "-",
+                        })
+        
+        routes.sort(key=lambda x: (x["path"], x["method"]))
+        
+        for route in routes:
+            table.add_row(route["method"], route["path"], route["name"])
+        
+        console.print(table)
+        console.print(f"\n[bold]Total routes:[/bold] {len(routes)}")
+    except ModuleNotFoundError as e:
+        typer.secho(
+            "✗ This command must run inside an Elric application project.",
+            fg=typer.colors.RED,
+        )
+        typer.secho(f"  Details: {e}", fg=typer.colors.YELLOW)
+        raise typer.Exit(1)
+    except Exception as e:
+        typer.secho(f"✗ Failed to list routes: {e}", fg=typer.colors.RED)
+        raise typer.Exit(1)

elric_cli/commands/serve.py

@@ -0,0 +1,33 @@
+import subprocess
+
+import typer
+
+from elric_cli.utils import get_project_root
+
+
+def serve(
+    host: str = typer.Option("0.0.0.0", help="Host to bind to"),
+    port: int = typer.Option(8000, help="Port to bind to"),
+    reload: bool = typer.Option(True, help="Enable auto-reload"),
+):
+    """Start the development server with uvicorn."""
+    typer.secho(f"Starting server on {host}:{port}...", fg=typer.colors.BLUE)
+    
+    cmd = [
+        "uvicorn",
+        "app:create_app",
+        "--factory",
+        "--host", host,
+        "--port", str(port),
+    ]
+    
+    if reload:
+        cmd.append("--reload")
+    
+    try:
+        subprocess.run(cmd, cwd=get_project_root())
+    except KeyboardInterrupt:
+        typer.secho("\n✓ Server stopped", fg=typer.colors.GREEN)
+    except FileNotFoundError:
+        typer.secho("✗ Uvicorn not found. Make sure it's installed.", fg=typer.colors.RED)
+        raise typer.Exit(1)