tf-starter 1.0.0

package/setup.py

@@ -0,0 +1,32 @@
+"""Setup configuration for tf-starter CLI tool."""
+
+from setuptools import setup, find_packages
+
+setup(
+    name="tf-starter",
+    version="1.0.0",
+    description="Enterprise-grade Terraform Infrastructure-as-Code project generator",
+    author="DevOps Team",
+    python_requires=">=3.9",
+    packages=find_packages(),
+    include_package_data=True,
+    package_data={
+        "tf_starter": ["templates/**/*"],
+    },
+    install_requires=[
+        "questionary>=2.0.0",
+        "jinja2>=3.1.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "tf-starter=tf_starter.cli:main",
+        ],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3.11",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Software Development :: Code Generators",
+        "Topic :: System :: Systems Administration",
+    ],
+)

package/tf_starter/__init__.py

@@ -0,0 +1,3 @@
+"""tf-starter: Enterprise-grade Terraform IaC project generator."""
+
+__version__ = "1.0.0"

package/tf_starter/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running tf-starter as `python -m tf_starter.cli`."""
+
+from tf_starter.cli import main
+
+if __name__ == "__main__":
+    main()

package/tf_starter/cli.py

@@ -0,0 +1,379 @@
+"""CLI entry point for tf-starter."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+import questionary
+from questionary import Style
+
+from tf_starter.generator import ProjectGenerator
+
+SUPPORTED_PROVIDERS = ["aws", "gcp", "azure"]
+
+# ---------------------------------------------------------------------------
+# AWS service categories — each maps to sub-modules inside a category folder.
+# "networking" and "security" are always included.
+# ---------------------------------------------------------------------------
+
+AWS_SERVICE_CATEGORIES = {
+    "compute": {
+        "label": "Compute     (EC2, ALB, Auto Scaling)",
+    },
+    "lambda": {
+        "label": "Lambda      (Serverless Functions)",
+    },
+    "apigateway": {
+        "label": "API Gateway (REST API + Lambda Integration)",
+    },
+    "database": {
+        "label": "Database    (RDS PostgreSQL)",
+    },
+    "kubernetes": {
+        "label": "Kubernetes  (EKS)",
+    },
+    "monitoring": {
+        "label": "Monitoring  (CloudWatch, SNS)",
+    },
+    "messaging": {
+        "label": "Messaging   (SQS)",
+    },
+    "storage": {
+        "label": "Storage     (S3)",
+    },
+}
+
+DEFAULT_REGIONS = {
+    "aws": [
+        "us-east-1",
+        "us-east-2",
+        "us-west-1",
+        "us-west-2",
+        "eu-west-1",
+        "eu-west-2",
+        "eu-central-1",
+        "ap-southeast-1",
+        "ap-northeast-1",
+    ],
+    "gcp": [
+        "us-central1",
+        "us-east1",
+        "us-west1",
+        "europe-west1",
+        "europe-west3",
+        "asia-east1",
+        "asia-southeast1",
+    ],
+    "azure": [
+        "eastus",
+        "eastus2",
+        "westus",
+        "westus2",
+        "westeurope",
+        "northeurope",
+        "southeastasia",
+        "japaneast",
+    ],
+}
+
+CUSTOM_STYLE = Style(
+    [
+        ("qmark", "fg:#00d7ff bold"),
+        ("question", "fg:#ffffff bold"),
+        ("answer", "fg:#00ff87 bold"),
+        ("pointer", "fg:#00d7ff bold"),
+        ("highlighted", "fg:#00d7ff bold"),
+        ("selected", "fg:#00ff87"),
+        ("separator", "fg:#6c6c6c"),
+        ("instruction", "fg:#6c6c6c"),
+    ]
+)
+
+
+def parse_args() -> argparse.Namespace:
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(
+        prog="tf-starter",
+        description="Enterprise-grade Terraform Infrastructure-as-Code project generator",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  tf-starter --provider aws --project-name myapp
+  tf-starter --provider gcp --project-name my-gcp-infra
+  tf-starter --provider azure --project-name azure-platform
+        """,
+    )
+
+    parser.add_argument(
+        "--provider",
+        type=str,
+        required=True,
+        choices=SUPPORTED_PROVIDERS,
+        help="Cloud provider (aws, gcp, azure)",
+    )
+
+    parser.add_argument(
+        "--project-name",
+        type=str,
+        required=True,
+        help="Name of the project to generate",
+    )
+
+    parser.add_argument(
+        "--output-dir",
+        type=str,
+        default=".",
+        help="Output directory (default: current directory)",
+    )
+
+    return parser.parse_args()
+
+
+def validate_project_name(name: str) -> bool:
+    """Validate project name contains only safe characters."""
+    import re
+
+    return bool(re.match(r"^[a-zA-Z][a-zA-Z0-9_-]*$", name))
+
+
+def ask_environments() -> list[str]:
+    """Interactively ask which environments to create."""
+    env_choices = [
+        questionary.Choice("dev", checked=True),
+        questionary.Choice("staging"),
+        questionary.Choice("prod"),
+        questionary.Choice("custom"),
+    ]
+
+    selected = questionary.checkbox(
+        "Select environments to create:",
+        choices=env_choices,
+        style=CUSTOM_STYLE,
+        validate=lambda x: len(x) > 0 or "You must select at least one environment",
+    ).ask()
+
+    if selected is None:
+        print("\nAborted.")
+        sys.exit(1)
+
+    environments = []
+    for env in selected:
+        if env == "custom":
+            custom_name = questionary.text(
+                "Enter custom environment name:",
+                style=CUSTOM_STYLE,
+                validate=lambda x: (
+                    len(x) > 0 and x.isalnum() or "Must be alphanumeric"
+                ),
+            ).ask()
+            if custom_name is None:
+                print("\nAborted.")
+                sys.exit(1)
+            environments.append(custom_name.lower())
+        else:
+            environments.append(env)
+
+    return environments
+
+
+def ask_services(provider: str) -> list[str]:
+    """Interactively ask which service categories to enable.
+
+    For AWS the user picks from real AWS service groups.
+    networking + security are always included automatically.
+    """
+    if provider == "aws":
+        print("\n  ℹ  Network (VPC, Subnets, IGW, NAT) — always included\n")
+
+        service_choices = [
+            questionary.Choice(
+                title=meta["label"],
+                value=key,
+                checked=(key == "compute"),
+            )
+            for key, meta in AWS_SERVICE_CATEGORIES.items()
+        ]
+    else:
+        # GCP / Azure keep original generic names
+        service_choices = [
+            questionary.Choice("compute", checked=True),
+            questionary.Choice("lambda"),
+            questionary.Choice("apigateway"),
+            questionary.Choice("database"),
+            questionary.Choice("kubernetes"),
+            questionary.Choice("monitoring"),
+            questionary.Choice("messaging"),
+            questionary.Choice("storage"),
+        ]
+
+    selected = questionary.checkbox(
+        "Select service categories to enable:",
+        choices=service_choices,
+        style=CUSTOM_STYLE,
+        validate=lambda x: len(x) > 0 or "You must select at least one service",
+    ).ask()
+
+    if selected is None:
+        print("\nAborted.")
+        sys.exit(1)
+
+    # Enforce dependency: kubernetes (EKS) requires compute
+    if "kubernetes" in selected and "compute" not in selected:
+        print("  ℹ  Kubernetes requires compute — auto-enabling compute (EC2, ALB, ASG).")
+        selected.append("compute")
+
+    # Enforce dependency: apigateway requires lambda
+    if "apigateway" in selected and "lambda" not in selected:
+        print("  ℹ  API Gateway requires Lambda — auto-enabling Lambda.")
+        selected.append("lambda")
+
+    # Always include network module
+    if "network" not in selected:
+        selected.insert(0, "network")
+
+    return selected
+
+
+def ask_region(provider: str) -> str:
+    """Interactively ask for the target region."""
+    regions = DEFAULT_REGIONS.get(provider, [])
+
+    region = questionary.select(
+        f"Select {provider.upper()} region:",
+        choices=regions + ["Other (type manually)"],
+        style=CUSTOM_STYLE,
+    ).ask()
+
+    if region is None:
+        print("\nAborted.")
+        sys.exit(1)
+
+    if region == "Other (type manually)":
+        region = questionary.text(
+            "Enter region:",
+            style=CUSTOM_STYLE,
+            validate=lambda x: len(x) > 0 or "Region cannot be empty",
+        ).ask()
+        if region is None:
+            print("\nAborted.")
+            sys.exit(1)
+
+    return region
+
+
+def ask_remote_backend() -> bool:
+    """Ask whether to enable remote state backend."""
+    result = questionary.confirm(
+        "Enable remote backend (recommended for teams)?",
+        default=True,
+        style=CUSTOM_STYLE,
+    ).ask()
+
+    if result is None:
+        print("\nAborted.")
+        sys.exit(1)
+
+    return result
+
+
+def print_banner() -> None:
+    """Print the tf-starter banner."""
+    banner = r"""
+  _    __             _              _
+ | |  / _|       ___| |_ __ _ _ __| |_ ___ _ __
+ | __| |_ _____ / __| __/ _` | '__| __/ _ \ '__|
+ | |_|  _|_____|\__ \ || (_| | |  | ||  __/ |
+  \__|_|        |___/\__\__,_|_|   \__\___|_|
+
+  Enterprise Terraform Project Generator v1.0.0
+"""
+    print(banner)
+
+
+def print_summary(
+    provider: str,
+    project_name: str,
+    environments: list[str],
+    services: list[str],
+    region: str,
+    enable_backend: bool,
+) -> None:
+    """Print generation summary."""
+    print("\n" + "=" * 55)
+    print("  ✔  Project created successfully!")
+    print("=" * 55)
+    print(f"  ✔  Project:      {project_name}")
+    print(f"  ✔  Provider:     {provider.upper()}")
+    print(f"  ✔  Region:       {region}")
+    print(f"  ✔  Environments: {', '.join(environments)}")
+    print(f"  ✔  Services:     {', '.join(services)}")
+    print(f"  ✔  Backend:      {'Remote (S3 + DynamoDB)' if enable_backend else 'Local'}")
+    print("=" * 55)
+    print()
+
+    print("  Generated modules:")
+    for svc in services:
+        print(f"    ✔  {svc}/")
+    print()
+
+    print(f"  Next steps:")
+    print(f"    cd {project_name}")
+    print(f"    make init")
+    print(f"    make plan")
+    print(f"    make apply")
+    print()
+
+
+def main() -> None:
+    """Main entry point for tf-starter CLI."""
+    print_banner()
+
+    args = parse_args()
+
+    if not validate_project_name(args.project_name):
+        print(
+            "Error: Project name must start with a letter and contain only "
+            "letters, digits, hyphens, or underscores."
+        )
+        sys.exit(1)
+
+    provider = args.provider.lower()
+    project_name = args.project_name
+
+    print(f"\n  Provider:     {provider.upper()}")
+    print(f"  Project name: {project_name}\n")
+
+    # Interactive questions
+    environments = ask_environments()
+    services = ask_services(provider)
+    region = ask_region(provider)
+    enable_backend = ask_remote_backend()
+
+    # Build context for templates
+    context = {
+        "project_name": project_name,
+        "provider": provider,
+        "region": region,
+        "environments": environments,
+        "services": services,
+        "enable_backend": enable_backend,
+    }
+
+    # Generate project
+    try:
+        generator = ProjectGenerator(
+            project_name=project_name,
+            output_dir=args.output_dir,
+            context=context,
+        )
+        generator.generate()
+    except Exception as e:
+        print(f"\n  ✘  Error generating project: {e}")
+        sys.exit(1)
+
+    print_summary(provider, project_name, environments, services, region, enable_backend)
+
+
+if __name__ == "__main__":
+    main()

package/tf_starter/generator.py

@@ -0,0 +1,171 @@
+"""Project generator — orchestrates template rendering and file creation."""
+
+from __future__ import annotations
+
+import os
+import stat
+from pathlib import Path
+from typing import Any
+
+from tf_starter.template_engine import TemplateEngine
+
+
+class ProjectGenerator:
+    """Generates a complete Terraform project from templates."""
+
+    def __init__(
+        self,
+        project_name: str,
+        output_dir: str,
+        context: dict[str, Any],
+    ) -> None:
+        self.project_name = project_name
+        self.output_dir = Path(output_dir).resolve()
+        self.project_dir = self.output_dir / project_name
+        self.context = context
+        self.provider = context["provider"]
+        self.engine = TemplateEngine(provider=self.provider, context=context)
+
+    # ------------------------------------------------------------------
+    # Public
+    # ------------------------------------------------------------------
+
+    def generate(self) -> Path:
+        """Generate the full project. Returns the project directory path."""
+        if self.project_dir.exists():
+            raise FileExistsError(
+                f"Directory '{self.project_dir}' already exists. "
+                "Remove it first or choose a different project name."
+            )
+
+        self._create_directory_tree()
+        self._generate_root_files()
+        self._generate_modules()
+        self._generate_environments()
+        self._generate_github_workflow()
+        self._generate_misc_files()
+
+        return self.project_dir
+
+    # ------------------------------------------------------------------
+    # Directory tree
+    # ------------------------------------------------------------------
+
+    def _create_directory_tree(self) -> None:
+        """Create the base directory structure."""
+        self.project_dir.mkdir(parents=True)
+
+        # modules/<service>/
+        for service in self.context["services"]:
+            (self.project_dir / "modules" / service).mkdir(parents=True)
+
+        # environments/<env>/
+        for env in self.context["environments"]:
+            (self.project_dir / "environments" / env).mkdir(parents=True)
+
+        # .github/workflows/
+        (self.project_dir / ".github" / "workflows").mkdir(parents=True)
+
+    # ------------------------------------------------------------------
+    # Root-level Terraform files
+    # ------------------------------------------------------------------
+
+    def _generate_root_files(self) -> None:
+        root_templates = [
+            ("root/main.tf.j2", "main.tf"),
+            ("root/providers.tf.j2", "providers.tf"),
+            ("root/variables.tf.j2", "variables.tf"),
+            ("root/outputs.tf.j2", "outputs.tf"),
+            ("root/versions.tf.j2", "versions.tf"),
+        ]
+
+        for template_name, output_name in root_templates:
+            content = self.engine.render(template_name)
+            self._write(output_name, content)
+
+        # backend.tf only when remote backend enabled
+        if self.context["enable_backend"]:
+            content = self.engine.render("root/backend.tf.j2")
+            self._write("backend.tf", content)
+
+    # ------------------------------------------------------------------
+    # Module files
+    # ------------------------------------------------------------------
+
+    def _generate_modules(self) -> None:
+        """Render each selected module's .tf files."""
+        for service in self.context["services"]:
+            module_template_dir = f"modules/{service}"
+
+            # Each module has main.tf, variables.tf, outputs.tf
+            for tf_file in ["main.tf", "variables.tf", "outputs.tf"]:
+                template_path = f"{module_template_dir}/{tf_file}.j2"
+                if self.engine.template_exists(template_path):
+                    content = self.engine.render(template_path)
+                    self._write(f"modules/{service}/{tf_file}", content)
+
+    # ------------------------------------------------------------------
+    # Environment files
+    # ------------------------------------------------------------------
+
+    def _generate_environments(self) -> None:
+        """Render per-environment files."""
+        for env in self.context["environments"]:
+            extra = {
+                "environment": env,
+                "is_prod": env == "prod",
+            }
+
+            env_templates = [
+                ("environments/main.tf.j2", f"environments/{env}/main.tf"),
+                ("environments/variables.tf.j2", f"environments/{env}/variables.tf"),
+                ("environments/terraform.tfvars.j2", f"environments/{env}/terraform.tfvars"),
+            ]
+
+            if self.context["enable_backend"]:
+                env_templates.append(
+                    ("environments/backend.tf.j2", f"environments/{env}/backend.tf")
+                )
+
+            for template_name, output_name in env_templates:
+                content = self.engine.render(template_name, extra_context=extra)
+                self._write(output_name, content)
+
+    # ------------------------------------------------------------------
+    # GitHub Actions
+    # ------------------------------------------------------------------
+
+    def _generate_github_workflow(self) -> None:
+        content = self.engine.render("github/terraform.yml.j2")
+        self._write(".github/workflows/terraform.yml", content)
+
+    # ------------------------------------------------------------------
+    # Makefile, init.sh, README, pre-commit
+    # ------------------------------------------------------------------
+
+    def _generate_misc_files(self) -> None:
+        misc_templates = [
+            ("misc/Makefile.j2", "Makefile"),
+            ("misc/init.sh.j2", "init.sh"),
+            ("misc/README.md.j2", "README.md"),
+            ("misc/pre-commit-config.yaml.j2", ".pre-commit-config.yaml"),
+        ]
+
+        for template_name, output_name in misc_templates:
+            content = self.engine.render(template_name)
+            self._write(output_name, content)
+
+        # Make init.sh executable
+        init_path = self.project_dir / "init.sh"
+        if init_path.exists():
+            init_path.chmod(init_path.stat().st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _write(self, relative_path: str, content: str) -> None:
+        """Write rendered content to a file inside the project directory."""
+        dest = self.project_dir / relative_path
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_text(content, encoding="utf-8")

package/tf_starter/template_engine.py

@@ -0,0 +1,80 @@
+"""Jinja2 template engine for rendering Terraform files."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader, StrictUndefined
+
+
+TEMPLATES_DIR = Path(__file__).parent / "templates"
+
+
+class TemplateEngine:
+    """Renders Jinja2 templates with the given context."""
+
+    def __init__(self, provider: str, context: dict[str, Any]) -> None:
+        self.provider = provider
+        self.context = context
+        self.template_dir = TEMPLATES_DIR / provider
+
+        if not self.template_dir.exists():
+            raise FileNotFoundError(
+                f"Template directory not found for provider '{provider}': "
+                f"{self.template_dir}"
+            )
+
+        self.env = Environment(
+            loader=FileSystemLoader(str(self.template_dir)),
+            undefined=StrictUndefined,
+            keep_trailing_newline=True,
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+        # Register custom filters
+        self.env.filters["tf_bool"] = self._tf_bool
+        self.env.filters["tf_list"] = self._tf_list
+
+    @staticmethod
+    def _tf_bool(value: bool) -> str:
+        """Convert Python bool to Terraform bool."""
+        return "true" if value else "false"
+
+    @staticmethod
+    def _tf_list(values: list[str]) -> str:
+        """Convert Python list to Terraform list literal."""
+        items = ", ".join(f'"{v}"' for v in values)
+        return f"[{items}]"
+
+    def render(self, template_path: str, extra_context: dict[str, Any] | None = None) -> str:
+        """Render a template with context.
+
+        Args:
+            template_path: Relative path within the provider template dir.
+            extra_context: Additional context merged on top of base context.
+
+        Returns:
+            Rendered template string.
+        """
+        ctx = {**self.context}
+        if extra_context:
+            ctx.update(extra_context)
+
+        template = self.env.get_template(template_path)
+        return template.render(**ctx)
+
+    def render_string(self, template_str: str, extra_context: dict[str, Any] | None = None) -> str:
+        """Render a raw template string with context."""
+        ctx = {**self.context}
+        if extra_context:
+            ctx.update(extra_context)
+
+        template = self.env.from_string(template_str)
+        return template.render(**ctx)
+
+    def template_exists(self, template_path: str) -> bool:
+        """Check if a template file exists."""
+        full_path = self.template_dir / template_path
+        return full_path.exists()

package/tf_starter/templates/aws/environments/backend.tf.j2

@@ -0,0 +1,16 @@
+# ---------------------------------------------------------------------------------------------------------------------
+# REMOTE BACKEND — {{ environment | upper }}
+# Project: {{ project_name }}
+# Generated by tf-starter
+# ---------------------------------------------------------------------------------------------------------------------
+
+terraform {
+  backend "s3" {
+    ### MUST EDIT THIS ###
+    bucket         = "{{ project_name }}-terraform-state"
+    key            = "{{ project_name }}/{{ environment }}/terraform.tfstate"
+    region         = "{{ region }}"
+    encrypt        = true
+    dynamodb_table = "{{ project_name }}-terraform-lock"
+  }
+}