environment-setup-assistant

Environment Setup Assistant

Generate automated setup scripts and detailed instructions for development environments across multiple platforms.

Quick Start

Generate Setup Script

Specify your requirements and get an automated setup script:

# Example: Python development environment
bash scripts/setup_python.sh

# Example: Node.js development environment
bash scripts/setup_nodejs.sh

# Example: Docker environment
bash scripts/setup_docker.sh

Get Platform-Specific Instructions

For manual setup or understanding what the scripts do, see [platform_instructions.md](references/platform_instructions.md).

Common Setup Scenarios

Scenario 1: New Team Member Onboarding

Goal: Set up complete development environment for a new developer

Approach:

1. Identify target platform (macOS, Linux, Windows)
2. List required tools (Git, Python, Node.js, Docker, etc.)
3. Generate comprehensive setup script
4. Provide verification checklist

Example Request: "Set up a Python and Node.js development environment on macOS"

Generated Output:

#!/usr/bin/env bash
# Complete Development Environment Setup

# Install Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install Git
brew install git

# Install Python via pyenv
brew install pyenv
pyenv install 3.11.0
pyenv global 3.11.0

# Install Node.js via nvm
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
nvm install --lts

# Install Docker Desktop
echo "Please download Docker Desktop from https://www.docker.com/products/docker-desktop"

# Install VS Code
brew install --cask visual-studio-code

# Verify installations
git --version
python --version
node --version

Scenario 2: Project-Specific Setup

Goal: Set up environment for a specific project with exact dependencies

Approach:

1. Analyze project requirements (package.json, requirements.txt, etc.)
2. Detect required runtime versions
3. Generate setup script with project initialization
4. Include virtual environment or project-specific configuration

Example Request: "Create setup script for a Django project requiring Python 3.11 and PostgreSQL"

Generated Output:

#!/usr/bin/env bash
# Django Project Environment Setup

# Install Python 3.11
if ! command -v python3.11 &> /dev/null; then
    # macOS
    brew install python@3.11
    # Linux: sudo apt-get install python3.11
fi

# Install PostgreSQL
brew install postgresql@15
brew services start postgresql@15

# Create virtual environment
python3.11 -m venv venv
source venv/bin/activate

# Install Django and dependencies
pip install django psycopg2-binary

# Create database
createdb myproject_dev

# Initialize Django project
django-admin startproject myproject .

echo "Setup complete! Activate venv: source venv/bin/activate"

Scenario 3: CI/CD Environment Replication

Goal: Replicate CI/CD environment locally

Approach:

1. Analyze CI configuration (.github/workflows, .gitlab-ci.yml, etc.)
2. Extract runtime versions and dependencies
3. Generate matching local setup
4. Include container-based option if applicable

Example Request: "Match my GitHub Actions environment locally (Ubuntu, Python 3.10, Node 18)"

Scenario 4: Multi-Language Development

Goal: Set up polyglot development environment

Approach:

1. Install version managers for each language
2. Set up common tools (Git, Docker, editor)
3. Configure shell environment
4. Provide switching instructions

Example Request: "Set up Python, Node.js, and Go development on Linux"

Setup Script Templates

Python Development

Use scripts/setup_python.sh:

• Installs Python 3.11
• Sets up virtual environment
• Installs common tools (pytest, black, mypy)
• Cross-platform (macOS, Linux, Windows/WSL)

Node.js Development

Use scripts/setup_nodejs.sh:

• Installs Node.js via nvm
• Installs package managers (npm, pnpm)
• Installs global tools (TypeScript, ESLint, Prettier)
• Cross-platform support

Docker Development

Use scripts/setup_docker.sh:

• Installs Docker Engine or Docker Desktop
• Installs Docker Compose
• Adds user to docker group (Linux)
• Verification steps

Platform-Specific Guidance

macOS Setup

See [platform_instructions.md](references/platform_instructions.md#macos-setup) for:

• Homebrew installation
• Command Line Tools
• Common package installation patterns
• Shell configuration (zsh)

Linux Setup

See [platform_instructions.md](references/platform_instructions.md#linux-setup) for:

• apt-get based installation (Ubuntu/Debian)
• Build tools and dependencies
• systemd service management
• Shell configuration (bash)

Windows Setup

See [platform_instructions.md](references/platform_instructions.md#windows-setup) for:

• WSL 2 setup (recommended)
• Native Windows tools
• PowerShell configuration
• Git Bash alternative

Development Tools

Version Managers

See [tool_guides.md](references/tool_guides.md#version-managers) for:

• pyenv: Python version management
• nvm: Node.js version management
• rbenv: Ruby version management

Code Editors

See [tool_guides.md](references/tool_guides.md#code-editors) for:

• VS Code: Installation and essential extensions
• JetBrains IDEs: PyCharm, WebStorm, IntelliJ
• Editor configuration

Database Tools

See [tool_guides.md](references/tool_guides.md#database-tools) for:

• PostgreSQL: Installation and pgAdmin
• MySQL/MariaDB: Installation and Workbench
• MongoDB: Installation and Compass
• Redis: Installation and CLI

Containerization

See [tool_guides.md](references/tool_guides.md#containerization) for:

• Docker: Setup and Docker Compose
• Kubernetes: Minikube and kubectl

Workflow

1. Assess Requirements

Determine what needs to be installed:

Questions to ask:
- What programming languages? (Python, Node.js, Java, Go, etc.)
- What databases? (PostgreSQL, MySQL, MongoDB, Redis, etc.)
- What tools? (Docker, Git, editor, etc.)
- What platform? (macOS, Linux, Windows)
- Team-wide or personal setup?

2. Choose Approach

Option A: Automated Script

• Fast, repeatable
• Use for standard setups
• Generates executable bash/shell script

Option B: Manual Instructions

• More control, educational
• Use when customization needed
• Provides step-by-step guide

Option C: Hybrid

• Script + explanations
• Best for team onboarding
• Script does heavy lifting, docs explain

3. Generate Setup Content

Based on requirements, generate:

• Setup script with error handling
• Platform-specific instructions
• Verification steps
• Troubleshooting tips

4. Include Verification

Always include verification steps:

# Verify installations
echo "Verifying setup..."

git --version || echo "❌ Git not installed"
python3 --version || echo "❌ Python not installed"
node --version || echo "❌ Node.js not installed"
docker --version || echo "❌ Docker not installed"

echo "✅ Setup verification complete"

5. Add Cleanup Instructions

Provide cleanup/uninstall steps if needed:

# Uninstall (if needed)
brew uninstall python@3.11
rm -rf venv

Best Practices

1. Make Scripts Idempotent

Scripts should be safe to run multiple times:

# Check before installing
if ! command -v python3 &> /dev/null; then
    brew install python@3.11
else
    echo "✅ Python already installed"
fi

2. Add Platform Detection

Detect OS and adapt:

detect_os() {
    if [[ "$OSTYPE" == "darwin"* ]]; then
        echo "macos"
    elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
        echo "linux"
    else
        echo "unknown"
    fi
}

OS=$(detect_os)

3. Provide Progress Feedback

Show what's happening:

echo "📦 Installing Python..."
brew install python@3.11
echo "✅ Python installed"

4. Handle Errors Gracefully

set -e  # Exit on error

# Or handle specific erro