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)"