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.

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 for:

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

Linux Setup

See platform_instructions.md for:

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

Windows Setup

See platform_instructions.md for:

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

Development Tools

Version Managers

See tool_guides.md for:

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

Code Editors

See tool_guides.md for:

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

Database Tools

See tool_guides.md for:

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

Containerization

See tool_guides.md 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 errors
if ! brew install python@3.11; then
    echo "❌ Failed to install Python"
    echo "Try installing manually from python.org"
    exit 1
fi

5. Include Documentation

Add comments explaining each step:

# Install Node.js via nvm (Node Version Manager)
# This allows managing multiple Node.js versions
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

Common Patterns

Virtual Environment Setup

# Python
python3 -m venv venv
source venv/bin/activate  # macOS/Linux
# venv\Scripts\activate    # Windows

# Node.js (using nvm)
nvm use 18

Tool Installation Check

check_installed() {
    if command -v $1 &> /dev/null; then
        echo "✅ $1 is installed"
        return 0
    else
        echo "❌ $1 is not installed"
        return 1
    fi
}

check_installed git
check_installed python3
check_installed node

Environment Variable Setup

# Add to ~/.bashrc or ~/.zshrc
cat >> ~/.bashrc << 'EOF'
export PATH="$HOME/.local/bin:$PATH"
export EDITOR=vim
EOF

source ~/.bashrc

Troubleshooting

Permission Issues

# macOS/Linux: Use sudo for system installations
sudo apt-get install package

# Avoid sudo for user-level tools
pip install --user package

PATH Issues

# Check PATH
echo $PATH

# Add to PATH (temporary)
export PATH="/usr/local/bin:$PATH"

# Add to PATH (permanent, in ~/.bashrc)
echo 'export PATH="/usr/local/bin:$PATH"' >> ~/.bashrc

Version Conflicts

# Use version managers to avoid conflicts
pyenv install 3.11.0  # Python
nvm install 18.16.0   # Node.js

Complete Example

Request: "Set up a full-stack JavaScript development environment on macOS"

Generated Script:

#!/usr/bin/env bash
# Full-Stack JavaScript Development Environment
# Platform: macOS

set -e

echo "🚀 Full-Stack JavaScript Setup"
echo "=============================="

# Install Homebrew
if ! command -v brew &> /dev/null; then
    echo "📦 Installing Homebrew..."
    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
fi

# Install Git
echo "📦 Installing Git..."
brew install git

# Install Node.js via nvm
echo "📦 Installing Node.js..."
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
export NVM_DIR="$HOME/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
nvm install --lts
nvm use --lts

# Install global packages
echo "📦 Installing global packages..."
npm install -g pnpm typescript ts-node nodemon

# Install PostgreSQL
echo "📦 Installing PostgreSQL..."
brew install postgresql@15
brew services start postgresql@15

# Install Redis
echo "📦 Installing Redis..."
brew install redis
brew services start redis

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

# Install VS Code
echo "📦 Installing VS Code..."
brew install --cask visual-studio-code

# Verify setup
echo ""
echo "✅ Setup Complete!"
echo ""
echo "Installed:"
echo "  - Git: $(git --version)"
echo "  - Node.js: $(node --version)"
echo "  - npm: $(npm --version)"
echo "  - pnpm: $(pnpm --version)"
echo "  - TypeScript: $(tsc --version)"
echo "  - PostgreSQL: $(postgres --version)"
echo "  - Redis: $(redis-server --version)"