env-var-mapper

name	env-var-mapper
description	Generate environment variable to CLI argument mapping with prefix support, type conversion, and fallback chains for configuration.
allowed-tools	Read, Write, Edit, Bash, Glob, Grep
graph	{"domains":["domain:software-engineering"],"specializations":["specialization:cli-mcp-development"],"skillAreas":["skill-area:cli-design","skill-area:configuration-management"],"roles":["role:backend-engineer","role:platform-engineer"],"workflows":["workflow:feature-development"],"topics":["topic:developer-experience"]}

Environment Variable Mapper

Generate environment variable to CLI argument mapping for flexible configuration.

Capabilities

• Generate env var to argument mapping logic
• Create prefix-based environment loading
• Set up type conversion for env vars
• Implement fallback chains (env -> config -> default)
• Configure .env file support
• Generate documentation for env vars

Usage

Invoke this skill when you need to:

• Map environment variables to CLI arguments
• Create prefix-based config loading
• Implement configuration fallback chains
• Support .env files in CLI applications

Inputs

Parameter	Type	Required	Description
language	string	Yes	Target language (typescript, python, go)
prefix	string	No	Env var prefix (e.g., MYAPP_)
mappings	array	Yes	Environment variable mappings
dotenvSupport	boolean	No	Enable .env file support (default: true)

Mapping Structure

{
  "mappings": [
    {
      "envVar": "PORT",
      "argument": "port",
      "type": "number",
      "default": 3000,
      "description": "Server port"
    },
    {
      "envVar": "DATABASE_URL",
      "argument": "database-url",
      "type": "string",
      "required": true,
      "sensitive": true
    },
    {
      "envVar": "DEBUG",
      "argument": "debug"
       
       
    
  

Generated Code Patterns

TypeScript Mapper

import { config } from 'dotenv';
import { z } from 'zod';

// Load .env file
config();

const ENV_PREFIX = 'MYAPP_';

// Environment schema
const envSchema = z.object({
  PORT: z.coerce.number().default(3000),
  DATABASE_URL: z.string().min(1),
  DEBUG: z.coerce.boolean().default(false),
  LOG_LEVEL: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
});

// Get prefixed env var
function getEnv(name: string): string | undefined {
  return process.env[`${ENV_PREFIX}${name}`] ?? process.env[name];
}

// Build env object with prefix support
function buildEnvObject(): <,  | > {
   {
    : (),
    : (),
    : (),
    : (),
  };
}


  () {
   env = ();
   envSchema.(env);
}


  (): [] {
   env = ();
   : [] = [];

   (env. !== ) {
    args.(, (env.));
  }
   (env.) {
    args.(, env.);
  }
   (env.) {
    args.();
  }
   (env. !== ) {
    args.(, env.);
  }

   args;
}


   = ;

Python Mapper

import os
from dataclasses import dataclass
from typing import Optional
from dotenv import load_dotenv

# Load .env file
load_dotenv()

ENV_PREFIX = 'MYAPP_'

@dataclass
class Environment:
    port: int = 3000
    database_url: str = ''
    debug: bool = False
    log_level: str = 'info'

def get_env(name: str) -> Optional[str]:
    """Get env var with prefix fallback."""
    return os.getenv(f'{ENV_PREFIX}{name}') or os.getenv(name)

def parse_bool(value: Optional[str]) -> bool:
    """Parse boolean from environment variable."""
    if value is None:
        return False
    return value.lower() in ('true', '1', 'yes', 'on')

def load_environment() -> Environment:
    
    env = Environment()

     port := get_env():
        env.port = (port)

     database_url := get_env():
        env.database_url = database_url
    :
         ValueError()

    env.debug = parse_bool(get_env())

     log_level := get_env():
         log_level   (, , , ):
             ValueError()
        env.log_level = log_level

     env

 () -> []:
    
    env = load_environment()
    args = []

     env.port != :
        args.extend([, (env.port)])
     env.database_url:
        args.extend([, env.database_url])
     env.debug:
        args.append()
     env.log_level != :
        args.extend([, env.log_level])

     args

ENV_DOCS = 

Go Mapper

package config

import (
    "fmt"
    "os"
    "strconv"
    "strings"

    "github.com/joho/godotenv"
)

const EnvPrefix = "MYAPP_"

type Environment struct {
    Port        int
    DatabaseURL string
    Debug       bool
    LogLevel    string
}

func init() {
    // Load .env file if present
    godotenv.Load()
}

func getEnv(name string) string {
    if val := os.Getenv(EnvPrefix + name); val != "" {
        return val
    }
    return os.Getenv(name)
}

func parseBool(value string) bool {
    lower := strings.ToLower(value)
    return lower == "true" || lower == "1" || lower == "yes" || lower == "on"
}

func LoadEnvironment() (*Environment, error) {
    env := &Environment{
        Port:     3000,
        Debug:    false,
        LogLevel: "info",
    }

    if port := getEnv("PORT"); port !=  {
        p, err := strconv.Atoi(port)
         err !=  {
             , fmt.Errorf(, port)
        }
        env.Port = p
    }

    env.DatabaseURL = getEnv()
     env.DatabaseURL ==  {
         , fmt.Errorf()
    }

    env.Debug = parseBool(getEnv())

     logLevel := getEnv(); logLevel !=  {
        valid := []{, , , }
        found := 
         _, v :=  valid {
             v == logLevel {
                found = 
                
            }
        }
         !found {
             , fmt.Errorf(, logLevel)
        }
        env.LogLevel = logLevel
    }

     env, 
}

Workflow

1. Define mappings - Specify env vars and arguments
2. Configure prefix - Set application prefix
3. Generate loader - Create env loading code
4. Add type conversion - Handle type coercion
5. Generate docs - Create env var documentation
6. Add validation - Required and constraints

Best Practices Applied

• Prefix support for namespacing
• Fallback from prefixed to non-prefixed
• Type-safe env var parsing
• Boolean string parsing
• .env file support
• Auto-generated documentation

Target Processes

• argument-parser-setup
• configuration-management-system
• cli-application-bootstrap