tf-mcp 0.3.0__tar.gz

tf_mcp-0.3.0/.gitignore

@@ -0,0 +1,24 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.venv/
+.env
+
+# uv
+uv.lock
+
+# OS
+.DS_Store
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Claude Code
+.claude/

tf_mcp-0.3.0/CLAUDE.md

@@ -0,0 +1,24 @@
+# Terraform MCP Server
+
+## Project Overview
+Multi-cloud MCP server for discovering and generating Terraform code from module catalogs across AWS, Azure, and GCP.
+
+## Architecture
+- `src/tf_mcp/server.py` — FastMCP entry point with tools and resources
+- `src/tf_mcp/registry.py` — Multi-cloud module registry, auto-discovers sibling repos
+- `src/tf_mcp/parser.py` — Cloud-agnostic HCL parser for variables, outputs, costs
+- `src/tf_mcp/models.py` — Pydantic models (ModuleInfo, VariableInfo, etc.)
+- `src/tf_mcp/codegen.py` — Multi-cloud Terraform code generation
+- `src/tf_mcp/dependencies.py` — Unified dependency/wiring lookup across clouds
+- `src/tf_mcp/clouds/{aws,azure,gcp}.py` — Per-cloud static metadata (layers, wiring, descriptions)
+
+## Adding a new cloud's module metadata
+1. Add module layers, descriptions, dependencies, wiring to `src/tf_mcp/clouds/<cloud>.py`
+2. The registry will auto-discover modules from the sibling `<cloud>-tf/modules/` directory
+3. For clouds without metadata, the registry discovers all subdirs with a `main.tf`
+
+## Key patterns
+- `python-hcl2` strips comments — cost blocks parsed via regex on raw text
+- hcl2 represents types as nested lists: `['list', 'string']` -> `list(string)`
+- All tools accept a `cloud` parameter; `list_modules` accepts optional cloud filter
+- Provider config (source, version, provider block) lives in per-cloud metadata

tf_mcp-0.3.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Michael Ujifusa
+
+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.

tf_mcp-0.3.0/PKG-INFO

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: tf-mcp
+Version: 0.3.0
+Summary: Multi-cloud MCP server for discovering and generating Terraform code from module catalogs
+Project-URL: Homepage, https://github.com/m-ujifusa/tf-mcp-server
+Project-URL: Repository, https://github.com/m-ujifusa/tf-mcp-server
+Project-URL: Issues, https://github.com/m-ujifusa/tf-mcp-server/issues
+License-Expression: MIT
+License-File: LICENSE
+Keywords: aws,azure,gcp,infrastructure-as-code,mcp,model-context-protocol,terraform
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: fastmcp>=2.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: python-hcl2>=5.0
+Description-Content-Type: text/markdown
+
+# Terraform Modules MCP Server
+
+A multi-cloud MCP server that lets AI assistants discover, understand, and generate Terraform code from module catalogs across AWS, Azure, and GCP.
+
+## What it does
+
+- **Discover modules** — list modules across all clouds with descriptions, dependencies, and costs
+- **Understand wiring** — see how modules connect (e.g., VPC outputs feed into EKS inputs)
+- **Estimate costs** — get per-module cost breakdowns by tier (dev/staging/prod)
+- **Generate code** — produce ready-to-use `.tf` files for single modules or full stacks
+
+## Quick start
+
+### Install via Claude Code
+
+Add to your `~/.mcp.json` (global) or `.claude/mcp.json` (per-project):
+
+```json
+{
+  "mcpServers": {
+    "tf-modules": {
+      "command": "uvx",
+      "args": ["tf-mcp"],
+      "env": {
+        "TF_MODULES_AWS_DIR": "/path/to/your/aws-tf/modules",
+        "TF_MODULES_AZURE_DIR": "/path/to/your/azure-tf/modules",
+        "TF_MODULES_GCP_DIR": "/path/to/your/gcp-tf/modules"
+      }
+    }
+  }
+}
+```
+
+Only include the `env` entries for clouds you have modules for.
+
+### Install via pip
+
+```bash
+pip install tf-mcp
+```
+
+### Run standalone
+
+```bash
+tf-mcp
+```
+
+## Prerequisites
+
+- Python >= 3.11
+- One or more directories containing Terraform modules
+
+## Module directory layout
+
+Point the server at directories containing Terraform modules. Each module should be a subdirectory with at least a `main.tf`:
+
+```
+your-modules-dir/
+  vpc/
+    main.tf
+    variables.tf
+    outputs.tf
+  eks-cluster/
+    main.tf
+    variables.tf
+    outputs.tf
+```
+
+The server auto-discovers all subdirectories containing a `main.tf`.
+
+## Configuration
+
+Tell the server where your modules live using environment variables:
+
+| Variable | Description |
+|----------|-------------|
+| `TF_MODULES_AWS_DIR` | Path to AWS `modules/` directory |
+| `TF_MODULES_AZURE_DIR` | Path to Azure `modules/` directory |
+| `TF_MODULES_GCP_DIR` | Path to GCP `modules/` directory |
+
+If no env vars are set, the server looks for sibling repos in the default layout:
+
+```
+parent-dir/
+  aws-tf/modules/
+  azure-tf/modules/
+  gcp-tf/modules/
+  tf-mcp-server/        # this repo
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_modules` | List modules with optional cloud filter |
+| `get_module_details` | Full variable/output/cost reference for one module |
+| `get_module_dependencies` | Dependency graph and output-to-input wiring |
+| `estimate_costs` | Cost estimates for a set of modules by tier |
+| `generate_module_code` | Generate `.tf` for a single module |
+| `generate_stack_code` | Generate a complete multi-module stack with auto-wiring |
+
+## Resources
+
+| URI | Description |
+|-----|-------------|
+| `modules://catalog` | Full listing across all clouds |
+| `modules://{cloud}/catalog` | Listing for one cloud |
+| `modules://{cloud}/{name}/readme` | Module README.md |
+| `modules://{cloud}/{name}/examples` | Module examples/main.tf |
+| `modules://{cloud}/dependency-graph` | Text dependency graph |
+| `modules://conventions` | Terraform conventions |
+
+## Development
+
+```bash
+git clone https://github.com/m-ujifusa/tf-mcp-server.git
+cd tf-mcp-server
+uv sync
+uv run tf-mcp
+```
+
+## License
+
+MIT

tf_mcp-0.3.0/README.md

@@ -0,0 +1,124 @@
+# Terraform Modules MCP Server
+
+A multi-cloud MCP server that lets AI assistants discover, understand, and generate Terraform code from module catalogs across AWS, Azure, and GCP.
+
+## What it does
+
+- **Discover modules** — list modules across all clouds with descriptions, dependencies, and costs
+- **Understand wiring** — see how modules connect (e.g., VPC outputs feed into EKS inputs)
+- **Estimate costs** — get per-module cost breakdowns by tier (dev/staging/prod)
+- **Generate code** — produce ready-to-use `.tf` files for single modules or full stacks
+
+## Quick start
+
+### Install via Claude Code
+
+Add to your `~/.mcp.json` (global) or `.claude/mcp.json` (per-project):
+
+```json
+{
+  "mcpServers": {
+    "tf-modules": {
+      "command": "uvx",
+      "args": ["tf-mcp"],
+      "env": {
+        "TF_MODULES_AWS_DIR": "/path/to/your/aws-tf/modules",
+        "TF_MODULES_AZURE_DIR": "/path/to/your/azure-tf/modules",
+        "TF_MODULES_GCP_DIR": "/path/to/your/gcp-tf/modules"
+      }
+    }
+  }
+}
+```
+
+Only include the `env` entries for clouds you have modules for.
+
+### Install via pip
+
+```bash
+pip install tf-mcp
+```
+
+### Run standalone
+
+```bash
+tf-mcp
+```
+
+## Prerequisites
+
+- Python >= 3.11
+- One or more directories containing Terraform modules
+
+## Module directory layout
+
+Point the server at directories containing Terraform modules. Each module should be a subdirectory with at least a `main.tf`:
+
+```
+your-modules-dir/
+  vpc/
+    main.tf
+    variables.tf
+    outputs.tf
+  eks-cluster/
+    main.tf
+    variables.tf
+    outputs.tf
+```
+
+The server auto-discovers all subdirectories containing a `main.tf`.
+
+## Configuration
+
+Tell the server where your modules live using environment variables:
+
+| Variable | Description |
+|----------|-------------|
+| `TF_MODULES_AWS_DIR` | Path to AWS `modules/` directory |
+| `TF_MODULES_AZURE_DIR` | Path to Azure `modules/` directory |
+| `TF_MODULES_GCP_DIR` | Path to GCP `modules/` directory |
+
+If no env vars are set, the server looks for sibling repos in the default layout:
+
+```
+parent-dir/
+  aws-tf/modules/
+  azure-tf/modules/
+  gcp-tf/modules/
+  tf-mcp-server/        # this repo
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_modules` | List modules with optional cloud filter |
+| `get_module_details` | Full variable/output/cost reference for one module |
+| `get_module_dependencies` | Dependency graph and output-to-input wiring |
+| `estimate_costs` | Cost estimates for a set of modules by tier |
+| `generate_module_code` | Generate `.tf` for a single module |
+| `generate_stack_code` | Generate a complete multi-module stack with auto-wiring |
+
+## Resources
+
+| URI | Description |
+|-----|-------------|
+| `modules://catalog` | Full listing across all clouds |
+| `modules://{cloud}/catalog` | Listing for one cloud |
+| `modules://{cloud}/{name}/readme` | Module README.md |
+| `modules://{cloud}/{name}/examples` | Module examples/main.tf |
+| `modules://{cloud}/dependency-graph` | Text dependency graph |
+| `modules://conventions` | Terraform conventions |
+
+## Development
+
+```bash
+git clone https://github.com/m-ujifusa/tf-mcp-server.git
+cd tf-mcp-server
+uv sync
+uv run tf-mcp
+```
+
+## License
+
+MIT

tf_mcp-0.3.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "tf-mcp"
+version = "0.3.0"
+description = "Multi-cloud MCP server for discovering and generating Terraform code from module catalogs"
+requires-python = ">=3.11"
+readme = "README.md"
+license = "MIT"
+keywords = ["terraform", "mcp", "model-context-protocol", "infrastructure-as-code", "aws", "azure", "gcp"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "License :: OSI Approved :: MIT License",
+]
+dependencies = [
+    "fastmcp>=2.0",
+    "python-hcl2>=5.0",
+    "pydantic>=2.0",
+]
+
+[project.scripts]
+tf-mcp = "tf_mcp.server:main"
+
+[project.urls]
+Homepage = "https://github.com/m-ujifusa/tf-mcp-server"
+Repository = "https://github.com/m-ujifusa/tf-mcp-server"
+Issues = "https://github.com/m-ujifusa/tf-mcp-server/issues"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

tf_mcp-0.3.0/src/tf_mcp/clouds/__init__.py

@@ -0,0 +1 @@
+"""Per-cloud module metadata: layers, dependencies, wiring, descriptions."""

tf_mcp-0.3.0/src/tf_mcp/clouds/aws.py

@@ -0,0 +1,157 @@
+"""AWS module metadata: layers, dependencies, wiring, descriptions.
+
+Moved from the original aws_tf_mcp.dependencies module.
+"""
+
+from __future__ import annotations
+
+# Layer assignments for topological ordering
+MODULE_LAYERS: dict[str, int] = {
+    "vpc": 1,
+    "ecr-repository": 1,
+    "ecs-cluster": 2,
+    "eks-cluster": 2,
+    "ec2-asg": 3,
+    "ecs-service": 3,
+    "eks-node-group": 3,
+    "eks-fargate-profile": 3,
+    "lambda-function": 3,
+    "eks-irsa": 4,
+}
+
+MODULE_DESCRIPTIONS: dict[str, str] = {
+    "vpc": "Multi-AZ VPC with public/private/database subnets, NAT Gateways, flow logs",
+    "eks-cluster": "EKS control plane with OIDC, secrets encryption, logging, addons",
+    "eks-node-group": "Managed EKS node group with launch template, scaling, taints/labels",
+    "eks-fargate-profile": "EKS Fargate profile for serverless Kubernetes pods",
+    "eks-irsa": "IAM Roles for Service Accounts (IRSA) or Pod Identity",
+    "ecs-cluster": "ECS cluster with Fargate/EC2 capacity providers, Container Insights",
+    "ecs-service": "ECS service + task definition + IAM roles + auto-scaling",
+    "ecr-repository": "ECR repo with lifecycle policies, scanning, cross-account access",
+    "ec2-asg": "EC2 Auto Scaling Group with launch template, mixed instances, ALB integration",
+    "lambda-function": "Lambda function with IAM role, VPC config, layers, log group",
+}
+
+DIRECT_DEPENDENCIES: dict[str, list[str]] = {
+    "vpc": [],
+    "ecr-repository": [],
+    "ecs-cluster": [],
+    "eks-cluster": ["vpc"],
+    "eks-node-group": ["eks-cluster", "vpc"],
+    "eks-fargate-profile": ["eks-cluster", "vpc"],
+    "eks-irsa": ["eks-cluster"],
+    "ecs-service": ["ecs-cluster", "vpc"],
+    "ec2-asg": ["vpc"],
+    "lambda-function": ["vpc"],
+}
+
+WIRING_MAP: dict[tuple[str, str], dict[str, str]] = {
+    ("vpc", "eks-cluster"): {
+        "vpc_id": "vpc_id",
+        "private_subnet_ids": "subnet_ids",
+    },
+    ("vpc", "eks-node-group"): {
+        "private_subnet_ids": "subnet_ids",
+    },
+    ("vpc", "eks-fargate-profile"): {
+        "private_subnet_ids": "subnet_ids",
+    },
+    ("vpc", "ec2-asg"): {
+        "vpc_id": "vpc_id",
+        "private_subnet_ids": "subnet_ids",
+    },
+    ("vpc", "ecs-service"): {
+        "vpc_id": "vpc_id",
+        "private_subnet_ids": "subnet_ids",
+    },
+    ("vpc", "lambda-function"): {
+        "private_subnet_ids": "vpc_config.subnet_ids",
+    },
+    ("eks-cluster", "eks-node-group"): {
+        "cluster_name": "cluster_name",
+    },
+    ("eks-cluster", "eks-fargate-profile"): {
+        "cluster_name": "cluster_name",
+    },
+    ("eks-cluster", "eks-irsa"): {
+        "oidc_provider_arn": "oidc_provider_arn",
+        "oidc_provider_url": "oidc_provider_url",
+        "cluster_name": "cluster_name",
+    },
+    ("ecs-cluster", "ecs-service"): {
+        "cluster_arn": "cluster_arn",
+        "cluster_name": "cluster_name",
+    },
+}
+
+PROVIDER_CONFIG = {
+    "source": "hashicorp/aws",
+    "version_constraint": "~> 5.0",
+    "provider_name": "aws",
+    "provider_block": 'provider "aws" {\n  region = var.region\n}',
+    "region_variable": "region",
+    "region_default": "us-east-1",
+    "tags_variable": "tags",
+    "tags_type": "map(string)",
+}
+
+IDENTITY_DEFAULTS: dict[str, dict[str, str]] = {
+    "vpc": {
+        "cidr_block": '"10.0.0.0/16"',
+        "azs": "local.azs",
+    },
+    "eks-cluster": {
+        "cluster_version": '"1.31"',
+    },
+    "eks-node-group": {
+        "node_group_name": '"general"',
+        "cluster_version": '"1.31"',
+    },
+    "eks-fargate-profile": {
+        "profile_name": '"default"',
+    },
+    "eks-irsa": {
+        "role_name_suffix": '"app"',
+        "service_account_namespace": '"default"',
+        "service_account_name": '"app"',
+    },
+    "ecs-cluster": {},
+    "ecs-service": {
+        "container_image": '"nginx:alpine"',
+    },
+    "ecr-repository": {},
+    "ec2-asg": {
+        "asg_name": '"web"',
+    },
+    "lambda-function": {
+        "function_name": '"worker"',
+        "runtime": '"python3.12"',
+        "handler": '"main.handler"',
+    },
+}
+
+KEY_OUTPUTS: dict[str, list[str]] = {
+    "vpc": ["vpc_id"],
+    "eks-cluster": ["cluster_name", "cluster_endpoint"],
+    "eks-node-group": ["node_group_name"],
+    "eks-fargate-profile": ["fargate_profile_name"],
+    "eks-irsa": ["role_arn"],
+    "ecs-cluster": ["cluster_name"],
+    "ecs-service": ["service_name"],
+    "ecr-repository": ["repository_url"],
+    "ec2-asg": ["asg_name"],
+    "lambda-function": ["function_arn"],
+}
+
+SHORT_NAMES: dict[str, str] = {
+    "vpc": "vpc",
+    "eks-cluster": "eks",
+    "eks-node-group": "node_group",
+    "eks-fargate-profile": "fargate",
+    "eks-irsa": "irsa",
+    "ecs-cluster": "ecs",
+    "ecs-service": "service",
+    "ecr-repository": "ecr",
+    "ec2-asg": "asg",
+    "lambda-function": "lambda",
+}

tf_mcp-0.3.0/src/tf_mcp/clouds/azure.py

@@ -0,0 +1,121 @@
+"""Azure module metadata: layers, dependencies, wiring, descriptions."""
+
+from __future__ import annotations
+
+# Layer assignments for topological ordering
+MODULE_LAYERS: dict[str, int] = {
+    "vnet": 1,
+    "container-registry": 1,
+    "aks-cluster": 2,
+    "container-app-environment": 2,
+    "aks-node-pool": 3,
+    "aks-workload-identity": 3,
+    "container-app": 3,
+    "function-app": 3,
+    "vm-scale-set": 3,
+}
+
+MODULE_DESCRIPTIONS: dict[str, str] = {
+    "vnet": "VNet with public/private/database subnets, NSGs, NAT Gateway, flow logs",
+    "aks-cluster": "AKS control plane with system node pool, RBAC, monitoring, workload identity",
+    "aks-node-pool": "AKS user node pool with autoscaling, spot instances, taints/labels",
+    "aks-workload-identity": "Managed identity with federated credential for Kubernetes workload identity",
+    "container-registry": "ACR with SKU tiers, geo-replication, retention, network rules, encryption",
+    "container-app-environment": "Container Apps Environment with VNet integration, Log Analytics",
+    "container-app": "Container App with containers, ingress, scaling rules, registries, secrets",
+    "function-app": "Function App with App Service Plan, Storage, Application Insights, VNet integration",
+    "vm-scale-set": "Linux VMSS with autoscaling, spot VMs, availability zones, managed identity",
+}
+
+DIRECT_DEPENDENCIES: dict[str, list[str]] = {
+    "vnet": [],
+    "container-registry": [],
+    "aks-cluster": ["vnet"],
+    "container-app-environment": [],
+    "aks-node-pool": ["aks-cluster", "vnet"],
+    "aks-workload-identity": ["aks-cluster"],
+    "container-app": ["container-app-environment"],
+    "function-app": ["vnet"],
+    "vm-scale-set": ["vnet"],
+}
+
+# Wiring: (source_module, target_module) -> {source_output: target_input}
+# Only includes direct output-to-input matches (same type).
+# vnet -> subnet_id wirings are omitted because private_subnet_ids is a list
+# and subnet_id expects a string — users must index: module.vnet.private_subnet_ids[0]
+WIRING_MAP: dict[tuple[str, str], dict[str, str]] = {
+    ("aks-cluster", "aks-node-pool"): {
+        "cluster_id": "cluster_id",
+    },
+    ("aks-cluster", "aks-workload-identity"): {
+        "oidc_issuer_url": "oidc_issuer_url",
+    },
+    ("container-app-environment", "container-app"): {
+        "environment_id": "container_app_environment_id",
+    },
+}
+
+PROVIDER_CONFIG = {
+    "source": "hashicorp/azurerm",
+    "version_constraint": "~> 4.0",
+    "provider_name": "azurerm",
+    "provider_block": 'provider "azurerm" {\n  features {}\n}',
+    "region_variable": "location",
+    "region_default": "eastus",
+    "tags_variable": "tags",
+    "tags_type": "map(string)",
+}
+
+IDENTITY_DEFAULTS: dict[str, dict[str, str]] = {
+    "vnet": {
+        "address_space": '"10.0.0.0/16"',
+    },
+    "aks-cluster": {
+        "kubernetes_version": '"1.31"',
+    },
+    "aks-node-pool": {
+        "node_pool_name": '"general"',
+    },
+    "aks-workload-identity": {
+        "identity_name": '"app"',
+        "namespace": '"default"',
+        "service_account_name": '"app"',
+    },
+    "container-registry": {},
+    "container-app-environment": {},
+    "container-app": {
+        "container_app_name": '"app"',
+    },
+    "function-app": {
+        "function_name": '"worker"',
+        "runtime_stack": '"python"',
+        "runtime_version": '"3.11"',
+    },
+    "vm-scale-set": {
+        "vmss_name": '"web"',
+    },
+}
+
+KEY_OUTPUTS: dict[str, list[str]] = {
+    "vnet": ["vnet_id"],
+    "aks-cluster": ["cluster_name", "cluster_id"],
+    "aks-node-pool": ["node_pool_name"],
+    "aks-workload-identity": ["identity_client_id"],
+    "container-registry": ["login_server"],
+    "container-app-environment": ["environment_id"],
+    "container-app": ["container_app_name", "fqdn"],
+    "function-app": ["function_app_name", "default_hostname"],
+    "vm-scale-set": ["vmss_id"],
+}
+
+SHORT_NAMES: dict[str, str] = {
+    "vnet": "vnet",
+    "aks-cluster": "aks",
+    "aks-node-pool": "node_pool",
+    "aks-workload-identity": "workload_id",
+    "container-registry": "acr",
+    "container-app-environment": "cae",
+    "container-app": "app",
+    "function-app": "func",
+    "vm-scale-set": "vmss",
+}

tf_mcp-0.3.0/src/tf_mcp/clouds/gcp.py

@@ -0,0 +1,31 @@
+"""GCP module metadata: layers, dependencies, wiring, descriptions.
+
+Stub — populated as modules are added to gcp-tf.
+"""
+
+from __future__ import annotations
+
+MODULE_LAYERS: dict[str, int] = {}
+
+MODULE_DESCRIPTIONS: dict[str, str] = {}
+
+DIRECT_DEPENDENCIES: dict[str, list[str]] = {}
+
+WIRING_MAP: dict[tuple[str, str], dict[str, str]] = {}
+
+PROVIDER_CONFIG = {
+    "source": "hashicorp/google",
+    "version_constraint": "~> 5.0",
+    "provider_name": "google",
+    "provider_block": 'provider "google" {\n  project = var.project_id\n  region  = var.region\n}',
+    "region_variable": "region",
+    "region_default": "us-central1",
+    "tags_variable": "labels",
+    "tags_type": "map(string)",
+}
+
+IDENTITY_DEFAULTS: dict[str, dict[str, str]] = {}
+
+KEY_OUTPUTS: dict[str, list[str]] = {}
+
+SHORT_NAMES: dict[str, str] = {}