configuration-generator

# Configuration Generator

Generate configuration files for applications, services, and infrastructure across various formats and frameworks.

## Quick Start

### Use Built-in Templates

Access ready-to-use configuration templates from assets:

```bash
# Docker Compose
cat assets/docker-compose.yml

# Kubernetes
cat assets/kubernetes-deployment.yaml

# GitHub Actions
cat assets/github-actions-workflow.yml
```

### Generate Custom Configuration

Specify your requirements to get tailored configuration files.

## Common Configuration Types

### Application Configurations

#### Package Managers

**Node.js (package.json)**
```json
{
  "name": "my-app",
  "version": "1.0.0",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "test": "jest",
    "build": "tsc"
  },
  "dependencies": {
    "express": "^4.18.0"
  },
  "devDependencies": {
    "typescript": "^5.0.0",
    "jest": "^29.0.0"
  }
}
```

**Python (requirements.txt)**
```
django==4.2.0
djangorestframework==3.14.0
psycopg2-binary==2.9.5
pytest==7.3.0
black==23.3.0
```

See **[app_configs.md](references/app_configs.md)** for:
- Package managers (npm, pip, cargo)
- Build tools (TypeScript, Webpack, Vite)
- Linters/formatters (ESLint, Prettier, Black)
- Testing frameworks (Jest, pytest)
- Environment files (.env, .editorconfig, .gitignore)

#### Build Configurations

**TypeScript (tsconfig.json)**
```json
{
  "compilerOptions": {
    "target": "ES2022",
    "module": "commonjs",
    "outDir": "./dist",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist"]
}
```

### Infrastructure Configurations

#### Docker

**Dockerfile (Multi-stage)**
```dockerfile
FROM node:18-alpine as builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
USER node
EXPOSE 3000
CMD ["node", "dist/index.js"]
```

**Docker Compose** - See `assets/docker-compose.yml`:
- Multi-service setup (web, database, cache)
- Environment variable configuration
- Volume management
- Network configuration

#### Kubernetes

**Deployment Configuration** - See `assets/kubernetes-deployment.yaml`:
- Deployment with replicas
- ConfigMap and Secret management
- Service and Ingress configuration
- Health probes
- Resource limits

**Example Deployment**:
```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    spec:
      containers:
      - name: web
        image: myapp:latest
        ports:
        - containerPort: 8000
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
```

See **[infra_configs.md](references/infra_configs.md)** for:
- Docker and Kubernetes
- Terraform (AWS, GCP, Azure)
- CI/CD pipelines
- Web servers (Nginx, Apache)

#### CI/CD Pipelines

**GitHub Actions** - See `assets/github-actions-workflow.yml`:
- Test, build, and deploy workflow
- Service containers (PostgreSQL, Redis)
- Docker image building
- Deployment automation

**Example Workflow**:
```yaml
name: CI/CD Pipeline

on:
  push:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-python@v4
        with:
          python-version: '3.11'
      - run: pip install -r requirements.txt
      - run: pytest
```

## Configuration Decision Tree

```
What type of configuration do you need?

├─ Application Config
│  ├─ Package manager? → package.json, requirements.txt, Cargo.toml
│  ├─ Build tool? → tsconfig.json, webpack.config.js, vite.config.ts
│  ├─ Linter/formatter? → .eslintrc, .prettierrc, pyproject.toml
│  └─ Environment? → .env, .editorconfig, .gitignore
│
├─ Container/Orchestration
│  ├─ Docker? → Dockerfile, docker-compose.yml
│  └─ Kubernetes? → deployment.yaml, service.yaml, ingress.yaml
│
├─ Infrastructure as Code
│  ├─ Terraform? → main.tf, variables.tf, outputs.tf
│  └─ CloudFormation? → template.yaml
│
├─ CI/CD
│  ├─ GitHub Actions? → .github/workflows/ci.yml
│  ├─ GitLab CI? → .gitlab-ci.yml
│  └─ CircleCI? → .circleci/config.yml
│
└─ Web Server
   ├─ Nginx? → nginx.conf
   └─ Apache? → httpd.conf, .htaccess
```

## Generation Approaches

### Approach 1: Template-Based

Use pre-built templates from `assets/`:

**When to use**:
- Standard setups
- Quick prototyping
- Learning/reference

**How**:
1. Identify needed template
2. Copy from assets
3. Customize variables
4. Deploy

**Example**:
```bash
# Copy Docker Compose template
cp assets/docker-compose.yml ./

# Edit environment variables
# Deploy
docker-compose up -d
```

### Approach 2: Requirements-Based Generation

Generate from scratch based on specific needs:

**When to use**:
- Custom requirements
- Complex setups
- Specific tech stack

**How**:
1. Specify requirements
2. Choose tech stack
3. Define constraints
4. Generate configuration

**Example Request**: "Generate a GitHub Actions workflow for a Python Django app with PostgreSQL, Redis, and deployment to AWS ECS"

**Generated Output**: Custom workflow with:
- Python 3.11 setup
- PostgreSQL and Redis services
- Django test suite
- Docker image build
- AWS ECS deployment

### Approach 3: Hybrid

Combine templates with customization:

**When to use**:
- Partially standard setup
- Template needs modification
- Best practices + customization

**How**:
1. Start with template
2. Identify customization points
3. Modify specific sections
4. Validate configuration

## Best Practices

### 1. Use Environment Variables

Separate configuration from code:

**Application**:
```python
# settings.py
import os

DATABASE_URL = os.getenv('DATABASE_URL')
SECRET_KEY = os.getenv('SECRET_KEY')
DEBUG = os.getenv('DEBUG', 'False') == 'True'
```

**.env file**:
```bash
DATABAS