This skill should be used when detecting programming languages in projects, determining language versions from config files, installing development environments (Rust, Python, Node.js), setting up LSP servers, installing CLI development tools, or configuring shell environments (oh-my-zsh, starship). Provides knowledge for language detection and environment setup in sandboxes.
From sandboxnpx claudepluginhub aaronbassett/agent-foundry --plugin sandboxThis skill uses the workspace's default tool permissions.
examples/starship.tomlscripts/detect_languages.pyscripts/parse_versions.pySearches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.
Searches prompts.chat for AI prompt templates by keyword or category, retrieves by ID with variable handling, and improves prompts via AI. Use for discovering or enhancing prompts.
Guides agent creation for Claude Code plugins with file templates, frontmatter specs (name, description, model), triggering examples, system prompts, and best practices.
Detect programming languages, parse version requirements, and install complete development environments for Rust, Python, and Node.js in Docker-based sandboxes.
This skill provides knowledge for setting up language-specific development environments inside sandbox containers. Focus on the three primary languages (Rust, Python, Node.js) and their associated tooling, LSP servers, and development utilities.
Identify languages by scanning for configuration and dependency files:
Rust indicators:
Cargo.toml - Rust project manifestCargo.lock - Dependency lock filerust-toolchain.toml - Rust version specification.rs files in src/ directoryPython indicators:
pyproject.toml - Modern Python project configrequirements.txt - Dependency listsetup.py - Package setup scriptPipfile - Pipenv config.python-version - Python version file.py filesNode.js indicators:
package.json - npm project manifestpackage-lock.json - npm lock filepnpm-lock.yaml - pnpm lock file.nvmrc - Node version specification.node-version - Alternative version file.js, .ts, .jsx, .tsx filesUse the scripts/detect_languages.py script to analyze a project:
# Returns detected languages and their config files
python3 scripts/detect_languages.py /path/to/project
Output format:
{
"rust": {
"detected": true,
"indicators": ["Cargo.toml", "src/main.rs"]
},
"python": {
"detected": true,
"indicators": ["pyproject.toml", "requirements.txt"]
},
"nodejs": {
"detected": true,
"indicators": ["package.json", ".nvmrc"]
}
}
Each language has standard files for version specification:
Primary: rust-toolchain.toml
[toolchain]
channel = "1.93.0"
# or
channel = "stable"
# or
channel = "nightly"
Parse with:
import toml
config = toml.load("rust-toolchain.toml")
version = config["toolchain"]["channel"]
Legacy: rust-toolchain (plain text)
1.93.0
Primary: pyproject.toml
[project]
requires-python = ">=3.14.2"
Parse with:
import toml
config = toml.load("pyproject.toml")
version_spec = config["project"]["requires-python"]
# Extract version: ">=3.14.2" → "3.14.2"
Alternative: .python-version
3.14.2
requirements.txt (less precise)
python>=3.14
Primary: .nvmrc
18.20.0
Or semantic versions:
lts/*
node
v18
Alternative: .node-version
18.20.0
package.json engines field
{
"engines": {
"node": ">=18.0.0"
}
}
Use scripts/parse_versions.py:
# Extract version requirements from project files
python3 scripts/parse_versions.py /path/to/project
Output:
{
"rust": "1.93.0",
"python": "3.14.2",
"nodejs": "18.20.0"
}
Install via rustup (preferred for version flexibility):
# Install specific version
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
sh -s -- -y --default-toolchain 1.93.0
# Install stable (current)
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
sh -s -- -y --default-toolchain stable
# Install nightly
RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
sh -s -- -y --default-toolchain nightly
Critical: Version keywords vs numbers
✅ GOOD - Always current:
RUN rustup install stable
RUN rustup install nightly
RUN rustup default stable
❌ BAD - Becomes outdated:
RUN rustup install 1.93.0 # Fixed version, will be old
When to use specific versions:
Components to install:
RUN rustup component add clippy rustfmt rust-analyzer
Standard tools:
# After Rust is installed
RUN cargo install cargo-dist cargo-deny cargo-release cocogitto
Install via apt (system Python):
RUN apt-get update && apt-get install -y \
python3 \
python3-pip \
python3-venv \
&& rm -rf /var/lib/apt/lists/*
Install via uv (for specific versions):
# Install uv first
RUN pip3 install --no-cache-dir uv
# Install specific Python version
RUN uv python install 3.14.2
# Install current stable
RUN uv python install
# Python doesn't have official LTS - use current stable
# When user asks for LTS, install current stable instead
Critical: Version keywords
✅ GOOD - Always current:
RUN uv python install # Latest stable
RUN pip3 install --upgrade pip # Latest pip
❌ BAD - Becomes outdated:
RUN uv python install 3.14 # Major version, but not latest patch
RUN uv python install 3.14.2 # Specific version, will be old
Standard tools:
RUN pip3 install --no-cache-dir uv ruff mypy black pytest
Install via nvm (preferred for version flexibility):
ENV NVM_DIR="/root/.nvm"
# Install nvm
RUN curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash
# Install current stable
RUN . "$NVM_DIR/nvm.sh" && nvm install node && nvm alias default node
# Install LTS
RUN . "$NVM_DIR/nvm.sh" && nvm install --lts && nvm alias default lts/*
# Install nightly (latest, including pre-release)
RUN . "$NVM_DIR/nvm.sh" && nvm install node --latest-npm
# Install specific version (when required)
RUN . "$NVM_DIR/nvm.sh" && nvm install 18.20.0
Critical: Version keywords
✅ GOOD - Always current:
RUN nvm install node # Current stable
RUN nvm install --lts # Current LTS
RUN nvm install node --latest-npm # Nightly/latest
❌ BAD - Becomes outdated:
RUN nvm install 18.20.0 # Specific version, will be old
RUN nvm install 18 # Major version, not latest
Standard tools:
RUN npm install -g pnpm typescript ts-node
Install via rustup:
RUN rustup component add rust-analyzer
Or via cargo (latest):
RUN cargo install rust-analyzer
Install via npm:
RUN npm install -g pyright
Or via pip:
RUN pip3 install pyright
Install via npm:
RUN npm install -g typescript-language-server typescript
When user requests LSP plugins from marketplace:
Add these plugins in Sandbox.toml:
[claude.plugins]
plugins = [
"rust-analyzer-lsp@claude-plugins-official",
"pyright-lsp@claude-plugins-official",
"typescript-lsp@claude-plugins-official"
]
Note: LSP servers must be installed in container. Plugins just configure Claude Code to use them.
Standard tools to install:
Via apt (if available):
RUN apt-get update && apt-get install -y \
ripgrep \
fd-find \
jq \
pdfgrep \
shellcheck \
&& rm -rf /var/lib/apt/lists/*
# Create symlinks where needed
RUN ln -s $(which fdfind) /usr/local/bin/fd
Via cargo:
RUN cargo install \
eza \
just \
repomix \
scc \
bfs \
xan \
git-cliff \
ast-grep \
ripgrep_all \
zizmor \
has
Via download (for binaries like fq):
RUN wget https://github.com/wader/fq/releases/latest/download/fq_linux_amd64.tar.gz && \
tar xzf fq_linux_amd64.tar.gz && \
mv fq /usr/local/bin/ && \
rm fq_linux_amd64.tar.gz
See references/tool-installation.md for complete installation commands and alternatives.
# Install zsh first
RUN apt-get update && apt-get install -y zsh && rm -rf /var/lib/apt/lists/*
# Install oh-my-zsh
RUN sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" "" --unattended
# Set zsh as default shell
RUN chsh -s $(which zsh)
# In .zshrc
plugins=(
git
docker
rust
python
node
npm
command-not-found
colored-man-pages
zsh-autosuggestions
zsh-syntax-highlighting
)
Install additional plugins:
RUN git clone https://github.com/zsh-users/zsh-autosuggestions ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-autosuggestions && \
git clone https://github.com/zsh-users/zsh-syntax-highlighting ${ZSH_CUSTOM:-~/.oh-my-zsh/custom}/plugins/zsh-syntax-highlighting
Add to .zshrc:
# eza aliases
alias l='eza -ao --sort=old -F=always --icons=auto --color=always --color-scale=size --color-scale-mode=gradient --group-directories-first --git --git-ignore --no-quotes --time-style=relative --no-permissions --no-user'
alias ll='l -l'
alias lk='eza -a -F=never --icons=never --group-directories-first'
# eza tree function
lt() {
eza -alT --icons=always --color=always --color-scale=all --color-scale-mode=gradient --group-directories-first --git --git-ignore --no-quotes --level=${1:-2}
}
Install:
RUN curl -sS https://starship.rs/install.sh | sh -s -- -y
Enable in .zshrc:
eval "$(starship init zsh)"
Configuration (starship.toml):
Create /root/.config/starship.toml:
add_newline = true
# Container indicator - highly visible
[container]
disabled = false
symbol = "🐳 "
style = "bold red"
format = "[$symbol]($style)"
# Hostname in red to indicate sandbox
[hostname]
ssh_only = false
format = "[$hostname]($style) "
style = "bold red"
# Directory
[directory]
style = "cyan"
truncation_length = 3
fish_style_pwd_dir_length = 1
# Prompt character
[character]
success_symbol = "[❯](bold red)"
error_symbol = "[❯](bold red)"
# Git
[git_branch]
format = "[$symbol$branch]($style) "
style = "bold purple"
[git_status]
style = "bold yellow"
# Language versions (show when relevant)
[rust]
symbol = "🦀 "
format = "[$symbol($version )]($style)"
[python]
symbol = "🐍 "
format = "[$symbol($version )]($style)"
[nodejs]
symbol = "⬢ "
format = "[$symbol($version )]($style)"
# Disable slow modules
[gcloud]
disabled = true
[kubernetes]
disabled = true
Themes: See references/starship-themes.md for alternative configurations.
Rust:
ENV PATH="/root/.cargo/bin:${PATH}"
ENV RUSTUP_HOME="/root/.rustup"
ENV CARGO_HOME="/root/.cargo"
Python:
ENV PYTHONUNBUFFERED=1
ENV PIP_NO_CACHE_DIR=1
Node.js:
ENV NVM_DIR="/root/.nvm"
ENV NODE_PATH="$NVM_DIR/versions/node/$(cat $NVM_DIR/alias/default)/lib/node_modules"
ENV PATH="$NVM_DIR/versions/node/$(cat $NVM_DIR/alias/default)/bin:$PATH"
Ensure language tools available in shell:
# .zshrc additions
export PATH="/root/.cargo/bin:$PATH"
export NVM_DIR="/root/.nvm"
[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
eval "$(starship init zsh)"
Scenario: Project has Python 3.12 in pyproject.toml, user says "use current stable" (3.14.2)
Resolution:
⚠️ Warning: Project specifies Python 3.12 in pyproject.toml, but you requested current stable (3.14.2).
Installing Python 3.14.2 as requested.
Note: You may need to update pyproject.toml to match:
requires-python = ">=3.14.2"
Scenario: Language detected but no version file
Resolution:
Detected Node.js project, but no .nvmrc or .node-version file found.
What version should I install?
- current (latest stable - recommended)
- lts (long-term support)
- nightly (bleeding edge)
- specific version (e.g., 18.20.0)
Detailed installation instructions and troubleshooting:
references/tool-installation.md - Complete installation commands for all toolsreferences/version-management.md - Advanced version detection and managementreferences/starship-themes.md - Starship configuration examplesUtility scripts for automation:
scripts/detect_languages.py - Language detectionscripts/parse_versions.py - Version extraction from config filesscripts/install_tools.sh - Batch tool installationWorking configuration examples:
examples/.zshrc - Complete zsh configurationexamples/starship.toml - Starship config with container themeWith docker-sandbox-setup:
With sandbox-config-management:
Detect languages: python3 scripts/detect_languages.py /project
Parse versions: python3 scripts/parse_versions.py /project
Version keywords (ALWAYS use for "current/latest"):
stable (not version numbers)uv python install (not 3.x)nvm install node (not version numbers)Version keywords (LTS):
stable (no official LTS)nvm install --ltsVersion keywords (nightly/bleeding edge):
nightlyuv python install nightlynvm install node --latest-npmLSP servers:
rustup component add rust-analyzernpm install -g pyrightnpm install -g typescript-language-serverShell setup:
curl -sS https://starship.rs/install.sh | sh.zshrc