lambda-forge-cli-aws 1.0.0__py3-none-any.whl

lambdaforge/bedrock_client.py

@@ -0,0 +1,109 @@
+"""Bedrock client — wrapper for Amazon Bedrock with retry and streaming."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import boto3
+
+
+class BedrockClient:
+    """Wrapper for Amazon Bedrock with built-in retry and error handling."""
+
+    DEFAULT_MODEL = "us.anthropic.claude-sonnet-4-5-20250929-v1:0"
+    REGION = "us-east-1"
+
+    def __init__(self, region: str = REGION, model_id: str = DEFAULT_MODEL) -> None:
+        self.client = boto3.client("bedrock-runtime", region_name=region)
+        self.region = region
+        self.model_id = model_id
+
+    def generate(
+        self,
+        system_prompt: str,
+        user_message: str,
+        max_tokens: int = 2048,
+        temperature: float = 0.3,
+    ) -> str:
+        """Generate text with Claude on Bedrock.
+
+        Args:
+            system_prompt: System instructions for Claude
+            user_message: The user's request
+            max_tokens: Maximum tokens in response
+            temperature: Sampling temperature (0.0-1.0)
+
+        Returns:
+            Generated text from Claude
+
+        Raises:
+            Exception: If the Bedrock call fails
+        """
+        try:
+            response = self.client.converse(
+                modelId=self.model_id,
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [{"text": user_message}],
+                    }
+                ],
+                system=[{"text": system_prompt}],
+                inferenceConfig={
+                    "maxTokens": max_tokens,
+                    "temperature": temperature,
+                },
+            )
+            return response["output"]["message"]["content"][0]["text"]
+
+        except Exception as e:
+            raise BedrockError(f"Bedrock call failed: {e}") from e
+
+    def generate_json(
+        self,
+        system_prompt: str,
+        user_message: str,
+        max_tokens: int = 2048,
+    ) -> dict[str, Any]:
+        """Generate JSON with Claude. Strips markdown fences if present."""
+        text = self.generate(
+            system_prompt=system_prompt,
+            user_message=user_message,
+            max_tokens=max_tokens,
+            temperature=0.2,
+        )
+        return self._extract_json(text)
+
+    def _extract_json(self, text: str) -> dict[str, Any]:
+        """Extract JSON from text, handling markdown code fences."""
+        text = text.strip()
+
+        # Strip markdown code fences
+        if text.startswith("```"):
+            lines = text.split("\n")
+            if lines[-1].startswith("```"):
+                text = "\n".join(lines[1:-1])
+            else:
+                text = "\n".join(lines[1:])
+
+        return json.loads(text)
+
+    def estimate_cost(
+        self,
+        input_tokens: int,
+        output_tokens: int,
+    ) -> float:
+        """Estimate cost in USD."""
+        # Approximate pricing for Claude 3.5 Sonnet
+        PRICES = {
+            "input": 0.003 / 1000,
+            "output": 0.015 / 1000,
+        }
+        return input_tokens * PRICES["input"] + output_tokens * PRICES["output"]
+
+
+class BedrockError(Exception):
+    """Raised when a Bedrock operation fails."""
+
+    pass

lambdaforge/cli.py

@@ -0,0 +1,428 @@
+"""LambdaForge CLI — main entry point."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from lambdaforge import __version__
+from lambdaforge.deploy import bootstrap_account, deploy_lambda, destroy_stack
+from lambdaforge.logs import show_logs
+from lambdaforge.renderer import TemplateRenderer
+from lambdaforge.spec_generator import SpecGenerator
+from lambdaforge.status import show_status
+from lambdaforge.templates import TEMPLATES
+from lambdaforge.upgrade import upgrade_lambda
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="lambdaforge")
+@click.option("--verbose", "-v", is_flag=True, help="Show detailed output")
+@click.option("--quiet", "-q", is_flag=True, help="Suppress non-essential output")
+@click.pass_context
+def cli(ctx: click.Context, verbose: bool, quiet: bool) -> None:
+    """LambdaForge — Lambda production-ready en 60 segundos."""
+    ctx.ensure_object(dict)
+    ctx.obj["verbose"] = verbose
+    ctx.obj["quiet"] = quiet
+    if quiet:
+        console.quiet = True
+
+
+@cli.command()
+@click.argument("name", required=False, default=None)
+@click.option(
+    "--template",
+    "-t",
+    default=None,
+    type=click.Choice(list(TEMPLATES.keys())),
+    help="Template to use",
+)
+@click.option("--description", default=None, help="Project description")
+@click.option("--author", default=None, help="Author name")
+@click.option("--email", default=None, help="Author email")
+@click.option("--runtime", default="python3.12", help="Lambda runtime")
+@click.option("--trigger", default="api-gateway", help="Trigger type")
+@click.option("--database", default=None, help="Database (dynamodb)")
+@click.option("--auth", default=None, help="Auth method (cognito, iam)")
+@click.option(
+    "--observability",
+    "-o",
+    default="xray",
+    help="Observability (xray, basic)",
+)
+@click.option("--region", default="us-east-1", help="AWS region")
+@click.option("--memory", default=512, help="Memory in MB")
+@click.option("--timeout", default=30, help="Timeout in seconds")
+@click.option(
+    "--no-specs",
+    is_flag=True,
+    help="Skip generating .kiro/specs/ (saves Bedrock cost)",
+)
+@click.option(
+    "--budget",
+    default=0.50,
+    type=float,
+    help="Maximum USD for Bedrock specs generation",
+)
+@click.option(
+    "--model",
+    default=None,
+    help="Bedrock model ID (default: Claude Sonnet 4.5)",
+)
+@click.option(
+    "--output",
+    "-d",
+    default=".",
+    type=click.Path(),
+    help="Output directory",
+)
+@click.option("--git/--no-git", default=True, help="Initialize git repo")
+def new(
+    name: str | None,
+    template: str | None,
+    description: str | None,
+    author: str | None,
+    email: str | None,
+    runtime: str,
+    trigger: str,
+    database: str | None,
+    auth: str | None,
+    observability: str,
+    region: str,
+    memory: int,
+    timeout: int,
+    no_specs: bool,
+    budget: float,
+    model: str | None,
+    output: str,
+    git: bool,
+) -> None:
+    """Create a new Lambda project.
+
+    Run without arguments for interactive mode:
+
+        lambdaforge new
+
+    Or pass arguments directly:
+
+        lambdaforge new payment-processor
+
+        lambdaforge new image-resizer --template python-s3
+
+        lambdaforge new webhooker --template python-queue --no-specs
+    """
+    # Interactive mode when no name is provided
+    if name is None:
+        import questionary
+
+        name = questionary.text(
+            "Project name:",
+            validate=lambda v: len(v) > 0 or "Project name is required",
+        ).ask()
+        if not name:
+            console.print("[yellow]Cancelled.[/yellow]")
+            sys.exit(0)
+
+        if template is None:
+            template = questionary.select(
+                "Template:",
+                choices=[
+                    questionary.Choice(
+                        title=f"{k} — {v['description']}",
+                        value=k,
+                    )
+                    for k, v in TEMPLATES.items()
+                ],
+            ).ask()
+
+        if description is None:
+            description = questionary.text(
+                "Description:",
+                default=f"Serverless {name} built with AWS Lambda",
+            ).ask()
+
+        if author is None:
+            author = questionary.text("Author name:", default="LambdaForge User").ask()
+
+        if email is None:
+            email = questionary.text("Author email:", default="user@example.com").ask()
+
+        region = questionary.text("AWS region:", default=region).ask() or region
+
+    # Defaults for non-interactive mode
+    if template is None:
+        template = "python-api"
+    if description is None:
+        description = f"Serverless {name} built with AWS Lambda"
+    if author is None:
+        author = "LambdaForge User"
+    if email is None:
+        email = "user@example.com"
+    console.print(
+        Panel(
+            f"[bold cyan]LambdaForge v{__version__}[/bold cyan]\n"
+            f"Creating: [yellow]{name}[/yellow]\n"
+            f"Template: [yellow]{template}[/yellow]\n"
+            f"Region: [yellow]{region}[/yellow]",
+            title="[bold]🔥 LambdaForge[/bold]",
+        )
+    )
+
+    output_path = Path(output) / name
+    if output_path.exists():
+        if not click.confirm(f"Directory {output_path} exists. Continue?", default=False):
+            console.print("[yellow]Cancelled.[/yellow]")
+            sys.exit(0)
+
+    # Build context for template rendering
+    context = {
+        "project_name": name,
+        "project_name_snake": name.replace("-", "_"),
+        "module_name": name.replace("-", "_"),
+        "description": description,
+        "author_name": author,
+        "author_email": email,
+        "runtime": runtime,
+        "trigger": trigger,
+        "database": database or "none",
+        "auth": auth or "none",
+        "observability": observability,
+        "aws_region": region,
+        "memory_mb": memory,
+        "timeout_seconds": timeout,
+    }
+
+    # 1. Render template
+    console.print("[dim]1/4 Rendering template...[/dim]")
+    renderer = TemplateRenderer()
+    try:
+        project_path = renderer.render(
+            template_name=template,
+            project_name=name,
+            context=context,
+            output_dir=output,
+        )
+    except FileNotFoundError:
+        console.print(f"[red]✗ Template '{template}' not found.[/red]")
+        console.print("[yellow]Run `lambdaforge templates` to see available options.[/yellow]")
+        sys.exit(1)
+    console.print(f"[green]✓ Template rendered: {project_path}[/green]")
+
+    # 2. Generate .kiro/specs/ (if not skipped)
+    if not no_specs:
+        console.print("[dim]2/4 Generating .kiro/specs/ via Bedrock...[/dim]")
+        try:
+            spec_gen = SpecGenerator(budget_usd=budget, model_id=model)
+            spec_gen.generate_all(project_path, template, context)
+            console.print(f"[green]✓ Specs generated[/green] (cost: ${spec_gen.total_cost:.3f})")
+        except Exception as e:
+            console.print(f"[yellow]⚠ Specs generation failed: {e}[/yellow]")
+            console.print("[yellow]Continuing without specs...[/yellow]")
+    else:
+        console.print("[dim]2/4 Skipping specs (--no-specs)[/dim]")
+
+    # 3. Initialize git
+    if git:
+        console.print("[dim]3/4 Initializing git...[/dim]")
+        try:
+            import git as gitpython
+
+            repo = gitpython.Repo.init(project_path)
+            repo.index.add(
+                [str(p.relative_to(project_path)) for p in project_path.rglob("*") if p.is_file()]
+            )
+            repo.index.commit("Initial Lambda scaffold from LambdaForge")
+            console.print("[green]✓ Git initialized[/green]")
+        except Exception as e:
+            console.print(f"[yellow]⚠ Git init failed: {e}[/yellow]")
+    else:
+        console.print("[dim]3/4 Skipping git (--no-git)[/dim]")
+
+    # 4. Done
+    console.print(
+        Panel(
+            f"[bold green]✓ Lambda '{name}' created in {project_path}[/bold green]\n\n"
+            f"Next steps:\n"
+            f"  1. cd {name}\n"
+            f"  2. pip install -r requirements.txt\n"
+            f"  3. pytest\n"
+            f"  4. cdk deploy",
+            title="[bold]Done[/bold]",
+            border_style="green",
+        )
+    )
+
+
+@cli.command()
+@click.argument("path", type=click.Path(exists=True), default=".")
+def upgrade(path: str) -> None:
+    """Upgrade an existing Lambda with LambdaForge best practices.
+
+    PATH defaults to the current directory if not specified.
+
+    Examples:
+
+        lambdaforge upgrade
+
+        lambdaforge upgrade ./my-existing-lambda
+    """
+    upgrade_lambda(Path(path))
+
+
+@cli.command()
+def templates() -> None:
+    """List available templates."""
+    table = Table(title="Available Lambda Templates", show_header=True, header_style="bold cyan")
+    table.add_column("Template", style="yellow")
+    table.add_column("Description")
+    table.add_column("Runtime", style="green")
+    table.add_column("Triggers")
+
+    for name, info in TEMPLATES.items():
+        table.add_row(
+            name,
+            info["description"],
+            info.get("runtime", "any"),
+            ", ".join(info.get("triggers", [])),
+        )
+
+    console.print(table)
+
+
+@cli.command()
+@click.option("--stack", "-s", default=None, help="CDK stack name to deploy")
+@click.option(
+    "--env",
+    "-e",
+    "environment",
+    default="dev",
+    type=click.Choice(["dev", "staging", "prod"]),
+    help="Target environment",
+)
+def deploy(stack: str | None, environment: str) -> None:
+    """Deploy the current Lambda to AWS.
+
+    Bundles dependencies, installs CDK packages, and runs cdk deploy.
+    Use --env to target different environments with different configs.
+
+    Examples:
+
+        lambdaforge deploy
+
+        lambdaforge deploy --env staging
+
+        lambdaforge deploy --env prod --stack my-api-prod
+    """
+    deploy_lambda(Path.cwd(), stack_name=stack, env=environment)
+
+
+@cli.command()
+@click.option("--region", "-r", default="us-east-1", help="AWS region to bootstrap")
+def bootstrap(region: str) -> None:
+    """Bootstrap CDK in your AWS account (one-time setup).
+
+    Creates the S3 bucket and IAM roles that CDK needs to deploy stacks.
+    Only needs to run once per account/region.
+
+    Examples:
+
+        lambdaforge bootstrap
+
+        lambdaforge bootstrap --region us-west-2
+    """
+    bootstrap_account(region=region)
+
+
+@cli.command()
+@click.option("--stack", "-s", default=None, help="CDK stack name to destroy")
+@click.option(
+    "--env",
+    "-e",
+    "environment",
+    default="dev",
+    type=click.Choice(["dev", "staging", "prod"]),
+    help="Target environment to destroy",
+)
+def destroy(stack: str | None, environment: str) -> None:
+    """Destroy the deployed Lambda stack from AWS.
+
+    Removes all resources created by `lambdaforge deploy`.
+
+    Examples:
+
+        lambdaforge destroy
+
+        lambdaforge destroy --env staging
+
+        lambdaforge destroy --env prod
+    """
+    destroy_stack(Path.cwd(), stack_name=stack, env=environment)
+
+
+@cli.command()
+def version() -> None:
+    """Show LambdaForge version."""
+    console.print(f"lambdaforge {__version__}")
+
+
+@cli.command()
+@click.option(
+    "--env",
+    "-e",
+    "environment",
+    default="dev",
+    type=click.Choice(["dev", "staging", "prod"]),
+    help="Environment to check",
+)
+def status(environment: str) -> None:
+    """Show deployment status of the current Lambda project.
+
+    Queries CloudFormation to display stack status, outputs, and tags.
+
+    Examples:
+
+        lambdaforge status
+
+        lambdaforge status --env prod
+    """
+    show_status(Path.cwd(), env=environment)
+
+
+@cli.command()
+@click.option(
+    "--env",
+    "-e",
+    "environment",
+    default="dev",
+    type=click.Choice(["dev", "staging", "prod"]),
+    help="Environment to fetch logs from",
+)
+@click.option("--lines", "-n", default=50, help="Number of log lines to show")
+@click.option("--errors", is_flag=True, help="Show only error logs")
+def logs(environment: str, lines: int, errors: bool) -> None:
+    """Show CloudWatch logs for the deployed Lambda.
+
+    Fetches recent log events and formats them with color coding.
+    Supports structured JSON logs from aws-lambda-powertools.
+
+    Examples:
+
+        lambdaforge logs
+
+        lambdaforge logs --env prod --lines 100
+
+        lambdaforge logs --errors
+    """
+    show_logs(Path.cwd(), env=environment, lines=lines, errors_only=errors)
+
+
+if __name__ == "__main__":
+    cli()