stackfordev 0.1.0__tar.gz

stackfordev-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

stackfordev-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: stackfordev
+Version: 0.1.0
+Summary: Generate tailored Dockerfiles for development environments
+License-File: LICENSE
+Keywords: docker,dockerfile,development,devcontainer
+Author: ZisisKostakakisGithubPersonal
+Author-email: dev@zisiskostakakis.com
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+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 :: Build Tools
+Requires-Dist: click (>=8.1,<9.0)
+Requires-Dist: httpx (>=0.27,<0.28)
+Requires-Dist: pydantic (>=2.9.2,<3.0.0)
+Requires-Dist: rich (>=13.0,<14.0)
+Description-Content-Type: text/markdown
+
+# StackForDev
+
+A service that generates optimized Dockerfiles based on project requirements.
+
+## Architecture
+
+![Architecture Diagram](./images/StackForDev.png)
+
+- AWS Lambda (Container Runtime)
+- Amazon API Gateway
+- Amazon ECR
+- Amazon S3
+- Terraform Cloud
+
+## Prerequisites
+
+- AWS Account
+- Terraform Cloud Account
+- Docker installed locally
+- Python 3.11+
+- Poetry for Python dependency management
+
+## Local Development
+
+1. Install dependencies:
+```bash
+poetry install
+```
+
+2. Set up environment variables:
+```bash
+export AWS_ACCESS_KEY_ID="your_access_key"
+export AWS_SECRET_ACCESS_KEY="your_secret_key"
+export AWS_REGION="your_region"
+export AWS_ACCOUNT_ID="your_account_id"
+```
+
+3. Initialize Terraform:
+```bash
+cd aws_resources
+terraform init
+```
+
+## Deployment
+
+The project uses Terraform Cloud for infrastructure management. Deployments are automated through GitHub integration.
+
+If you want to deploy through the Terraform Cloud UI, you can do so by following these steps:
+
+1. Create a new workspace in Terraform Cloud
+2. Add the GitHub repository to the workspace
+3. Create a new variable set in the workspace and add the AWS credentials as variables
+4. Run the plan and apply buttons in the Terraform Cloud UI
+
+### Manual Deployment Steps
+
+1. Push changes to GitHub
+2. Terraform Cloud automatically plans and applies changes
+3. New Docker image is built and pushed to ECR
+4. Lambda function is updated with the latest image
+
+## API Usage
+
+### Generate Dockerfile
+```bash
+curl -X POST https://api.example.com/prod/generate-dockerfile \
+  -H "x-api-key: your_api_key" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "config": {
+        "language": "python",
+        "dependency_stack": "Django",
+        "extra_dependencies": ["pandas", "numpy"],
+        "language_version": "3.11"
+    }
+}'
+```
+
+## Project Structure
+
+```
+├── aws_resources/          # Terraform infrastructure code
+├── docker_templates/       # Dockerfile templates
+├── generate_dockerfile.py  # Main Lambda function
+├── pyproject.toml         # Python dependencies
+└── README.md
+```
+
+## Infrastructure
+
+- **API Gateway**: Regional endpoint with API key authentication
+- **Lambda**: Container-based function with 30s timeout
+- **S3**: Private bucket for Dockerfile storage
+- **ECR**: Container registry for Lambda images
+- **IAM**: Least-privilege access policies
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Security
+
+- S3 bucket with public access blocked
+- IAM role-based access control
+- API Gateway with usage plans and API keys
+- ECR repository with specific permissions

stackfordev-0.1.0/README.md

@@ -0,0 +1,114 @@
+# StackForDev
+
+A service that generates optimized Dockerfiles based on project requirements.
+
+## Architecture
+
+![Architecture Diagram](./images/StackForDev.png)
+
+- AWS Lambda (Container Runtime)
+- Amazon API Gateway
+- Amazon ECR
+- Amazon S3
+- Terraform Cloud
+
+## Prerequisites
+
+- AWS Account
+- Terraform Cloud Account
+- Docker installed locally
+- Python 3.11+
+- Poetry for Python dependency management
+
+## Local Development
+
+1. Install dependencies:
+```bash
+poetry install
+```
+
+2. Set up environment variables:
+```bash
+export AWS_ACCESS_KEY_ID="your_access_key"
+export AWS_SECRET_ACCESS_KEY="your_secret_key"
+export AWS_REGION="your_region"
+export AWS_ACCOUNT_ID="your_account_id"
+```
+
+3. Initialize Terraform:
+```bash
+cd aws_resources
+terraform init
+```
+
+## Deployment
+
+The project uses Terraform Cloud for infrastructure management. Deployments are automated through GitHub integration.
+
+If you want to deploy through the Terraform Cloud UI, you can do so by following these steps:
+
+1. Create a new workspace in Terraform Cloud
+2. Add the GitHub repository to the workspace
+3. Create a new variable set in the workspace and add the AWS credentials as variables
+4. Run the plan and apply buttons in the Terraform Cloud UI
+
+### Manual Deployment Steps
+
+1. Push changes to GitHub
+2. Terraform Cloud automatically plans and applies changes
+3. New Docker image is built and pushed to ECR
+4. Lambda function is updated with the latest image
+
+## API Usage
+
+### Generate Dockerfile
+```bash
+curl -X POST https://api.example.com/prod/generate-dockerfile \
+  -H "x-api-key: your_api_key" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "config": {
+        "language": "python",
+        "dependency_stack": "Django",
+        "extra_dependencies": ["pandas", "numpy"],
+        "language_version": "3.11"
+    }
+}'
+```
+
+## Project Structure
+
+```
+├── aws_resources/          # Terraform infrastructure code
+├── docker_templates/       # Dockerfile templates
+├── generate_dockerfile.py  # Main Lambda function
+├── pyproject.toml         # Python dependencies
+└── README.md
+```
+
+## Infrastructure
+
+- **API Gateway**: Regional endpoint with API key authentication
+- **Lambda**: Container-based function with 30s timeout
+- **S3**: Private bucket for Dockerfile storage
+- **ECR**: Container registry for Lambda images
+- **IAM**: Least-privilege access policies
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes
+4. Push to the branch
+5. Create a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Security
+
+- S3 bucket with public access blocked
+- IAM role-based access control
+- API Gateway with usage plans and API keys
+- ECR repository with specific permissions

stackfordev-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[tool.poetry]
+name = "stackfordev"
+version = "0.1.0"
+description = "Generate tailored Dockerfiles for development environments"
+authors = ["ZisisKostakakisGithubPersonal <dev@zisiskostakakis.com>"]
+readme = "README.md"
+packages = [{include = "src"}]
+keywords = ["docker", "dockerfile", "development", "devcontainer"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Build Tools",
+]
+
+[tool.poetry.scripts]
+stackfordev = "src.cli.main:cli"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+pydantic = "^2.9.2"
+click = "^8.1"
+rich = "^13.0"
+httpx = "^0.27"
+
+[tool.poetry.group.lambda.dependencies]
+boto3 = "^1.35.62"
+python-dotenv = "^1.0.1"
+boto3-stubs = {extras = ["essential"], version = "^1.35.62"}
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.3"
+respx = "^0.21"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+pythonpath = [
+  "src"
+]

stackfordev-0.1.0/src/cli/api_client.py

@@ -0,0 +1,37 @@
+"""HTTP client for the StackForDev public API endpoint."""
+
+import httpx
+
+from src.cli.config import API_URL
+from src.generator_core import GenerateDockerfileRequest
+
+
+def generate_via_api(config: GenerateDockerfileRequest, timeout: float = 15.0) -> dict:
+    """POST to the public CLI endpoint and return the response body.
+
+    Returns:
+        dict with keys: message, key, dockerfile
+
+    Raises:
+        RuntimeError on network/HTTP errors with user-friendly messages.
+    """
+    payload = {
+        "config": {
+            "language": config.language,
+            "dependency_stack": config.dependency_stack,
+            "extra_dependencies": config.extra_dependencies,
+            "language_version": config.language_version,
+        }
+    }
+
+    try:
+        response = httpx.post(API_URL, json=payload, timeout=timeout)
+        response.raise_for_status()
+        return response.json()
+    except httpx.TimeoutException:
+        raise RuntimeError("Request timed out. Try again or use --local to generate offline.")
+    except httpx.ConnectError:
+        raise RuntimeError("Could not connect to the API. Check your internet or use --local.")
+    except httpx.HTTPStatusError as e:
+        body = e.response.text
+        raise RuntimeError(f"API returned {e.response.status_code}: {body}")

stackfordev-0.1.0/src/cli/commands/generate.py

@@ -0,0 +1,85 @@
+"""stackfordev generate command."""
+
+import json
+import sys
+
+import click
+
+from src.cli.config import (
+    LANGUAGE_VERSIONS,
+    LANGUAGE_STACKS,
+    validate_language,
+    validate_version,
+    validate_stack,
+)
+from src.cli.display import print_dockerfile, print_saved
+from src.generator_core import GenerateDockerfileRequest, DockerfileGenerator
+
+
+@click.command()
+@click.option("--language", "-l", type=str, default=None, help="Language: python, javascript, go")
+@click.option("--stack", "-s", type=str, default=None, help="Dependency stack (e.g. 'Django Stack')")
+@click.option("--version", "-v", "lang_version", type=str, default=None, help="Language version (e.g. 3.11)")
+@click.option("--extras", "-e", type=str, default=None, help="Comma-separated extra dependencies")
+@click.option("--output", "-o", type=click.Path(), default=None, help="Save Dockerfile to path")
+@click.option("--local", is_flag=True, default=False, help="Generate offline (no API call)")
+@click.option("--json-output", "--json", "json_mode", is_flag=True, default=False, help="Output raw JSON")
+def generate(language, stack, lang_version, extras, output, local, json_mode):
+    """Generate a Dockerfile for a development environment."""
+    # If any flag is missing and we're in a TTY, go interactive
+    if (language is None or stack is None or lang_version is None) and sys.stdin.isatty():
+        from src.cli.interactive import prompt_config
+        language, lang_version, stack, extras_list = prompt_config(language, lang_version, stack)
+    elif language is None or stack is None or lang_version is None:
+        click.echo(
+            "Error: --language, --stack, and --version are required in non-interactive mode.\n"
+            "Example: stackfordev generate -l python -s 'Django Stack' -v 3.11",
+            err=True,
+        )
+        sys.exit(1)
+    else:
+        extras_list = [e.strip() for e in extras.split(",") if e.strip()] if extras else []
+
+    try:
+        lang = validate_language(language)
+        validate_version(lang, lang_version)
+        validate_stack(lang, stack)
+    except ValueError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+    config = GenerateDockerfileRequest(
+        language=lang,
+        dependency_stack=stack,
+        extra_dependencies=extras_list,
+        language_version=lang_version,
+    )
+
+    if local:
+        generator = DockerfileGenerator(config=config)
+        dockerfile_content = generator.generate_dockerfile()
+    else:
+        try:
+            from src.cli.api_client import generate_via_api
+            result = generate_via_api(config)
+            dockerfile_content = result["dockerfile"]
+        except Exception as e:
+            click.echo(f"API error: {e}\nTip: use --local to generate offline.", err=True)
+            sys.exit(1)
+
+    if json_mode:
+        click.echo(json.dumps({
+            "language": lang,
+            "stack": stack,
+            "version": lang_version,
+            "dockerfile": dockerfile_content,
+        }))
+        return
+
+    if output:
+        with open(output, "w", encoding="utf-8") as f:
+            f.write(dockerfile_content)
+        print_saved(output)
+        return
+
+    print_dockerfile(dockerfile_content, lang, stack)

stackfordev-0.1.0/src/cli/config.py

@@ -0,0 +1,38 @@
+"""CLI configuration: language versions, stacks, and validation."""
+
+from src.generator_core import STACK_PACKAGES
+
+LANGUAGE_VERSIONS: dict[str, list[str]] = {
+    "python": ["3.12", "3.11", "3.10", "3.9"],
+    "javascript": ["22", "20", "18"],
+    "go": ["1.23", "1.22", "1.21"],
+}
+
+LANGUAGE_STACKS: dict[str, list[str]] = {
+    "python": ["Django Stack", "Flask Stack", "Data Science Stack", "Web Scraping Stack", "Machine Learning Stack"],
+    "javascript": ["Express Stack", "React Stack", "Vue.js Stack", "Node.js API Stack", "Full-Stack JavaScript"],
+    "go": ["Gin Stack", "Beego Stack", "Web Framework Stack", "Microservices Stack", "Data Processing Stack"],
+}
+
+API_URL = "https://f88slnkaa6.execute-api.eu-west-2.amazonaws.com/prod/cli/generate-dockerfile"
+
+
+def validate_language(language: str) -> str:
+    lang = language.lower()
+    if lang not in LANGUAGE_VERSIONS:
+        raise ValueError(f"Unsupported language: {language}. Supported: {', '.join(LANGUAGE_VERSIONS)}")
+    return lang
+
+
+def validate_version(language: str, version: str) -> str:
+    versions = LANGUAGE_VERSIONS[language]
+    if version not in versions:
+        raise ValueError(f"Unsupported version '{version}' for {language}. Supported: {', '.join(versions)}")
+    return version
+
+
+def validate_stack(language: str, stack: str) -> str:
+    stacks = LANGUAGE_STACKS[language]
+    if stack not in stacks:
+        raise ValueError(f"Unsupported stack '{stack}' for {language}. Supported: {', '.join(stacks)}")
+    return stack

stackfordev-0.1.0/src/cli/display.py

@@ -0,0 +1,29 @@
+"""Rich display helpers for CLI output."""
+
+import sys
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+
+
+def is_tty() -> bool:
+    return sys.stdout.isatty()
+
+
+def print_dockerfile(content: str, language: str, stack: str) -> None:
+    """Print Dockerfile with Rich syntax highlighting if TTY, raw otherwise."""
+    if not is_tty():
+        sys.stdout.write(content)
+        return
+
+    console = Console()
+    syntax = Syntax(content, "dockerfile", theme="monokai", line_numbers=True)
+    console.print(Panel(syntax, title=f"[bold green]Dockerfile — {language} / {stack}[/]", border_style="green"))
+    console.print()
+    console.print("[dim]Tip: docker build -t myapp -f Dockerfile . && docker run -it -v $(pwd):/usr/src/app myapp[/]")
+
+
+def print_saved(path: str) -> None:
+    console = Console(stderr=True)
+    console.print(f"[green]Saved to {path}[/]")

stackfordev-0.1.0/src/cli/interactive.py

@@ -0,0 +1,51 @@
+"""Interactive prompts for when CLI flags are missing."""
+
+from rich.console import Console
+from rich.prompt import Prompt
+
+from src.cli.config import LANGUAGE_VERSIONS, LANGUAGE_STACKS
+
+
+def prompt_config(
+    language: str | None = None,
+    lang_version: str | None = None,
+    stack: str | None = None,
+) -> tuple[str, str, str, list[str]]:
+    """Prompt the user interactively for missing config values.
+
+    Returns:
+        (language, version, stack, extras_list)
+    """
+    console = Console()
+    console.print("[bold]StackForDev[/] — Generate a Dockerfile\n")
+
+    languages = list(LANGUAGE_VERSIONS.keys())
+    if language is None:
+        console.print("Available languages:")
+        for i, l in enumerate(languages, 1):
+            console.print(f"  {i}. {l}")
+        raw = Prompt.ask("Select language", choices=[str(i) for i in range(1, len(languages) + 1)], default="1")
+        language = languages[int(raw) - 1]
+    language = language.lower()
+
+    versions = LANGUAGE_VERSIONS[language]
+    if lang_version is None:
+        console.print("\nAvailable versions:")
+        for i, v in enumerate(versions, 1):
+            console.print(f"  {i}. {v}")
+        raw = Prompt.ask("Select version", choices=[str(i) for i in range(1, len(versions) + 1)], default="1")
+        lang_version = versions[int(raw) - 1]
+
+    stacks = LANGUAGE_STACKS[language]
+    if stack is None:
+        console.print("\nAvailable stacks:")
+        for i, s in enumerate(stacks, 1):
+            console.print(f"  {i}. {s}")
+        number_choices = [str(i) for i in range(1, len(stacks) + 1)]
+        raw = Prompt.ask("Select stack", choices=number_choices, default="1")
+        stack = stacks[int(raw) - 1]
+
+    extras_input = Prompt.ask("Extra dependencies (comma-separated, Enter to skip)", default="")
+    extras_list = [e.strip() for e in extras_input.split(",") if e.strip()]
+
+    return language, lang_version, stack, extras_list

stackfordev-0.1.0/src/cli/main.py

@@ -0,0 +1,14 @@
+"""StackForDev CLI entrypoint."""
+
+import click
+
+from src.cli.commands.generate import generate
+
+
+@click.group()
+@click.version_option(package_name="stackfordev")
+def cli():
+    """StackForDev — Generate tailored Dockerfiles for development environments."""
+
+
+cli.add_command(generate)

stackfordev-0.1.0/src/docker_templates/go_template.py

@@ -0,0 +1,27 @@
+"""File to generate a Dockerfile for a Go application."""
+START_OF_TEMPLATE = """# Help
+
+# To execute Go code in the container:
+    # docker exec manager go version
+
+# To start an interactive shell:
+    # docker exec -it manager bash
+
+FROM golang:GO_VERSION-bullseye
+
+WORKDIR /usr/src/app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \\
+    git \\
+    curl \\
+    build-essential \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Go packages
+RUN go install DEPENDENCY_STACK EXTRA_DEPENDENCIES
+"""
+
+END_OF_TEMPLATE = """
+CMD ["bash"]
+"""

stackfordev-0.1.0/src/docker_templates/javascript_template.py

@@ -0,0 +1,27 @@
+"""File to generate a Dockerfile for a JavaScript/Node.js application."""
+START_OF_TEMPLATE = """# Help
+
+# To execute Node.js code in the container:
+    # docker exec manager node --version
+
+# To start an interactive Node.js shell:
+    # docker exec -it manager node
+
+FROM node:NODE_VERSION-bullseye
+
+WORKDIR /usr/src/app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \\
+    git \\
+    curl \\
+    build-essential \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Install global packages
+RUN npm install -g DEPENDENCY_STACK EXTRA_DEPENDENCIES
+"""
+
+END_OF_TEMPLATE = """
+CMD ["bash"]
+"""

stackfordev-0.1.0/src/docker_templates/python_template.py

@@ -0,0 +1,30 @@
+"""File to generate a Dockerfile for a Python application."""
+START_OF_TEMPLATE = """# Help
+
+# To execute Python code in the container:
+    # docker exec manager python3 --version
+
+# To start an interactive python shell:
+    # docker exec -it manager python3
+
+FROM python:PYTHON_VERSION-bullseye
+
+WORKDIR /usr/src/app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \\
+    git \\
+    curl \\
+    build-essential \\
+    python3-dev \\
+    && rm -rf /var/lib/apt/lists/*
+
+ENV PYTHONUNBUFFERED=1
+
+# Install extra dependencies
+RUN pip install DEPENDENCY_STACK EXTRA_DEPENDENCIES
+"""
+
+END_OF_TEMPLATE = """
+CMD ["bash"]
+"""

stackfordev-0.1.0/src/generate_dockerfile.py

@@ -0,0 +1,106 @@
+"""Script to generate the dockerfile based on the API parameters"""
+
+import json
+import os
+from typing import Any, Optional
+
+from dotenv import load_dotenv
+
+from src.generator_core import (
+    TEMPLATE_REGISTRY,
+    SUPPORTED_LANGUAGES,
+    STACK_PACKAGES,
+    GenerateDockerfileRequest,
+    DockerfileGenerator,
+    generate_dockerfile_key_name,
+)
+from src.s3_helper import upload_to_s3, check_if_file_exists_in_s3
+
+load_dotenv()
+
+# Re-export for backward compatibility
+__all__ = [
+    "TEMPLATE_REGISTRY",
+    "SUPPORTED_LANGUAGES",
+    "STACK_PACKAGES",
+    "GenerateDockerfileRequest",
+    "DockerfileGenerator",
+    "generate_dockerfile_key_name",
+    "is_running_on_lambda",
+    "validate_env_vars",
+    "lambda_handler",
+    "CORS_HEADERS",
+]
+
+
+def is_running_on_lambda() -> bool:
+    """Determine if the code is executing in an AWS Lambda environment."""
+    return bool(os.getenv("AWS_LAMBDA_FUNCTION_NAME"))
+
+
+def validate_env_vars() -> None:
+    """Validate required environment variables are present."""
+    if not os.getenv("S3_BUCKET"):
+        raise ValueError("S3_BUCKET environment variable is not set")
+    if not os.getenv("AWS_REGION"):
+        raise ValueError("AWS_REGION environment variable is not set")
+
+
+CORS_HEADERS = {
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Headers": "Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token",
+    "Access-Control-Allow-Methods": "POST,OPTIONS",
+}
+
+
+def _response(status_code: int, body: dict) -> dict:
+    return {
+        "statusCode": status_code,
+        "headers": CORS_HEADERS,
+        "body": json.dumps(body),
+    }
+
+
+def lambda_handler(event: dict[str, Any], context: Optional[dict] = None) -> dict:
+    """AWS Lambda handler for the Dockerfile generation API endpoint."""
+    try:
+        validate_env_vars()
+        config = GenerateDockerfileRequest.from_event(event)
+        generator = DockerfileGenerator(config=config)
+        dockerfile_content = generator.generate_dockerfile()
+
+        dockerfile_key_name = generate_dockerfile_key_name(config)
+        path = f"{config.language.lower()}-images/"
+
+        if not is_running_on_lambda():
+            os.makedirs(path, exist_ok=True)
+            with open(os.path.join(path, dockerfile_key_name), "w", encoding="utf-8") as f:
+                f.write(dockerfile_content)
+
+        aws_region = os.getenv("AWS_REGION")
+        bucket = os.getenv("S3_BUCKET")
+
+        if is_running_on_lambda():
+            s3_key = os.path.join(path, dockerfile_key_name)
+            if not check_if_file_exists_in_s3(
+                bucket=bucket,
+                key=s3_key,
+                region_name=aws_region,
+            ):
+                try:
+                    upload_to_s3(
+                        file_path=s3_key,
+                        bucket=bucket,
+                        content=dockerfile_content,
+                        region_name=aws_region,
+                    )
+                except Exception as e:
+                    return _response(500, {"error": f"Failed to upload Dockerfile to S3, {e}"})
+
+        return _response(200, {
+            "message": "Dockerfile generated successfully",
+            "key": dockerfile_key_name,
+            "dockerfile": dockerfile_content,
+        })
+    except Exception as e:
+        return _response(400, {"error": str(e)})

stackfordev-0.1.0/src/generator_core.py

@@ -0,0 +1,108 @@
+"""Core Dockerfile generation logic, decoupled from AWS dependencies."""
+
+import re
+from typing import Any
+
+from pydantic import BaseModel, Field, field_validator
+
+from src.docker_templates import python_template, javascript_template, go_template
+
+TEMPLATE_REGISTRY: dict[str, tuple] = {
+    "python": (python_template.START_OF_TEMPLATE, python_template.END_OF_TEMPLATE, "PYTHON_VERSION"),
+    "javascript": (javascript_template.START_OF_TEMPLATE, javascript_template.END_OF_TEMPLATE, "NODE_VERSION"),
+    "go": (go_template.START_OF_TEMPLATE, go_template.END_OF_TEMPLATE, "GO_VERSION"),
+}
+
+SUPPORTED_LANGUAGES = set(TEMPLATE_REGISTRY.keys())
+
+STACK_PACKAGES: dict[str, str] = {
+    # Python
+    "Django Stack": "django djangorestframework psycopg2-binary Pillow djangorestframework-simplejwt requests",
+    "Flask Stack": "flask flask-restful flask-sqlalchemy flask-migrate requests",
+    "Data Science Stack": "pandas numpy matplotlib scikit-learn jupyter",
+    "Web Scraping Stack": "beautifulsoup4 scrapy requests lxml pandas",
+    "Machine Learning Stack": "scikit-learn tensorflow keras numpy matplotlib",
+    # JavaScript (npm global packages)
+    "Express Stack": "express mongoose body-parser cors dotenv",
+    "React Stack": "react react-router redux axios",
+    "Vue.js Stack": "vue@latest vue-router vuex axios",
+    "Node.js API Stack": "express mongoose jsonwebtoken",
+    "Full-Stack JavaScript": "express mongoose react redux",
+    # Go (go install paths)
+    "Gin Stack": "github.com/gin-gonic/gin@latest",
+    "Beego Stack": "github.com/beego/beego/v2@latest",
+    "Web Framework Stack": "github.com/labstack/echo/v4@latest",
+    "Microservices Stack": "github.com/go-kit/kit@latest",
+    "Data Processing Stack": "github.com/onsi/ginkgo/v2@latest",
+}
+
+
+class GenerateDockerfileRequest(BaseModel):
+    """Pydantic model representing the API request for Dockerfile generation."""
+
+    language: str = Field(
+        ..., description="Programming language for the Dockerfile (e.g. python, node)"
+    )
+    dependency_stack: str = Field(
+        ..., description="Primary framework or dependency stack (e.g. Django, FastAPI)"
+    )
+    extra_dependencies: list[str] = Field(
+        default_factory=list, description="List of additional packages to install"
+    )
+    language_version: str = Field(
+        ..., description="Version of the programming language (e.g. 3.11)"
+    )
+
+    @field_validator("extra_dependencies", mode="before")
+    @classmethod
+    def sanitize_dependencies(cls, v: list[str]) -> list[str]:
+        """Validate extra dependencies against injection attacks."""
+        pattern = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9._\-\[\]>=<!, ]*$")
+        for dep in v:
+            if not pattern.match(dep):
+                raise ValueError(
+                    f"Invalid dependency name: '{dep}'. "
+                    "Only alphanumeric characters, hyphens, dots, and version specifiers are allowed."
+                )
+        return v
+
+    @property
+    def extra_dependencies_str(self) -> str:
+        """Convert the list of extra dependencies to a space-separated string."""
+        return " ".join(self.extra_dependencies)
+
+    @classmethod
+    def from_event(cls, event: dict[str, Any]) -> "GenerateDockerfileRequest":
+        """Create a GenerateDockerfileRequest instance from an API Gateway event."""
+        import json
+        dict_obj = json.loads(event["body"])
+        return cls(**dict_obj["config"])
+
+
+class DockerfileGenerator(BaseModel):
+    """Service class for generating Dockerfile content."""
+
+    config: GenerateDockerfileRequest
+
+    def generate_dockerfile(self) -> str:
+        """Generate Dockerfile content using the template and configuration."""
+        language = self.config.language.lower()
+        if language not in TEMPLATE_REGISTRY:
+            raise ValueError(f"Unsupported language: {self.config.language}. Supported: {', '.join(SUPPORTED_LANGUAGES)}")
+
+        start_template, end_template, version_placeholder = TEMPLATE_REGISTRY[language]
+        stack_packages = STACK_PACKAGES.get(self.config.dependency_stack, self.config.dependency_stack)
+        return (
+            start_template.replace(version_placeholder, self.config.language_version)
+            .replace("DEPENDENCY_STACK", stack_packages)
+            .replace("EXTRA_DEPENDENCIES", self.config.extra_dependencies_str)
+            + end_template
+        )
+
+
+def generate_dockerfile_key_name(config: GenerateDockerfileRequest) -> str:
+    """Generate a unique S3 key name for the Dockerfile."""
+    return (
+        f"dockerfile-{config.language}-{config.dependency_stack}-"
+        + f"{config.language_version}-{'-'.join(config.extra_dependencies)}.dockerfile"
+    )

stackfordev-0.1.0/src/s3_helper.py

@@ -0,0 +1,47 @@
+"""Helper script with S3 functions"""
+from typing import Optional
+import boto3
+from mypy_boto3_s3.client import S3Client
+
+
+def upload_to_s3(
+    file_path: str,
+    bucket: Optional[str],
+    content: str,
+    region_name: Optional[str],
+) -> None:
+    """Upload to S3
+
+    Args:
+        file_path: S3 File path to save
+        bucket:
+        content: Body of the file
+        region_name:
+
+    Raises:
+        ValueError:
+    """
+    if not bucket:
+        raise ValueError("Bucket is required")
+
+    if not region_name:
+        raise ValueError("Region name is required")
+
+    s3_client: S3Client = boto3.client("s3", region_name=region_name)
+    s3_client.put_object(Bucket=bucket, Key=file_path, Body=content)
+
+
+def check_if_file_exists_in_s3(bucket: Optional[str], key: str, region_name: Optional[str]) -> bool:
+    """Check if a file exists in S3"""
+    if not bucket:
+        raise ValueError("Bucket is required")
+
+    if not region_name:
+        raise ValueError("Region name is required")
+
+    s3_client: S3Client = boto3.client("s3", region_name=region_name)
+    try:
+        s3_client.head_object(Bucket=bucket, Key=key)
+        return True
+    except Exception:
+        return False