Jarvy

Jarvy is a fast, cross-platform CLI that standardizes and automates local development environment setup from a declarative jarvy.toml config file. It installs 200+ tools using native package managers (Homebrew, apt, dnf, winget, Chocolatey) and ensures every team member has an identical development environment -- no cloud VMs, no containers, no recurring costs.

Why Jarvy?

• Instant onboarding -- New developers run one command and get a fully configured workstation in seconds, not days
• Dev environment as code -- jarvy.toml is version-controlled, replacing wiki pages and tribal knowledge
• Cross-platform -- Same config works on macOS, Linux, and Windows using native package managers
• Local and offline -- No cloud dependency, no container overhead, full native performance
• Safe and idempotent -- Run repeatedly; Jarvy detects what's already installed and skips it
• 200+ tools supported -- From git and docker to terraform, kubectl, and language runtimes

Contributor Onboarding (Clean Laptop)

Brand-new machine, nothing installed? Two commands:

# 1. Install Jarvy
curl -fsSL https://raw.githubusercontent.com/bearbinary/jarvy/main/dist/scripts/install.sh | bash

# 2. Clone + provision everything else
git clone https://github.com/bearbinary/jarvy && cd jarvy && make setup

That's it. make setup runs scripts/bootstrap.sh, which is idempotent — re-run any time you've been away from the project or the environment drifts.

Windows (PowerShell): swap step 1 for irm https://raw.githubusercontent.com/bearbinary/jarvy/main/dist/scripts/install.ps1 | iex, then run the same git clone ... && cd jarvy && make setup.

Already have a tool installed via your own package manager? Jarvy detects it and skips reinstall. It only adds what's missing.

Want to skip the curl pipe? brew install jarvy or cargo install jarvy work too — assuming you already have brew or cargo on the machine.

Installation

# With Cargo
cargo install jarvy

# With Homebrew (macOS/Linux)
brew install jarvy

# Or download a binary from GitHub Releases
# https://github.com/bearbinary/jarvy/releases

Verify installation:

jarvy --version

Early-Release Channel (Opt-In)

Jarvy ships pre-release tags (-rc.N, -beta.N) to a separate channel so you can validate fixes and features before they land in stable. Opt in any of three ways — all are reversible.

On install — set JARVY_CHANNEL before running the install script:

# Unix
JARVY_CHANNEL=beta curl -fsSL \
  https://raw.githubusercontent.com/bearbinary/jarvy/main/dist/scripts/install.sh | bash

# Windows PowerShell
$env:JARVY_CHANNEL = 'beta'
irm https://raw.githubusercontent.com/bearbinary/jarvy/main/dist/scripts/install.ps1 | iex

Per-update — pass --channel:

jarvy update --channel beta

Persistent — set in ~/.jarvy/config.toml:

[update]
channel = "beta"   # stable | beta | nightly

Channel semantics:

Opting into beta is the easiest way to help validate releases. Issues tagged release-blocker or regression filed against a pre-release block its promotion to stable — see docs/release-testing.md for the full process.

Quick Start

1. Create a config

# Interactive wizard
jarvy init

# Or from a template
jarvy init --template react
jarvy init --template rust-cli
jarvy init --template python-api
jarvy init --template k8s-admin

Or create jarvy.toml manually in your project root:

[privileges]
use_sudo = false

[provisioner]
git = "latest"
node = "20"
docker = "latest"
jq = "latest"

2. Run setup

jarvy setup

Output:

Setting up development environment...
  [OK] git 2.44.0 (installed: 2.44.0) - satisfies requirement
  [INSTALL] node 20 - installing via brew...
  [OK] node 20.11.1 installed successfully
  [OK] docker 25.0.3 (installed: 25.0.3) - satisfies requirement
  [INSTALL] jq latest - installing via brew...
  [OK] jq 1.7.1 installed successfully

Setup complete: 4 tools (2 installed, 2 already satisfied)

3. Share with your team

Commit jarvy.toml to your repository. Add to your project's README:

# Set up development environment
cargo install jarvy && jarvy setup

Configuration

Jarvy supports simple and detailed tool specifications:

[privileges]
use_sudo = false

[provisioner]
# Simple: tool = "version"
git = "latest"
node = "20"
python = "3.12"
docker = "latest"

# Detailed: tool = { version, version_manager }
rust = { version = "stable", version_manager = true }

# Role-based tool sets
[roles.frontend]
description = "Frontend development"
tools = ["node", "bun", "typescript"]

[roles.devops]
description = "DevOps/Platform engineering"
extends = "base"
tools = ["kubectl", "terraform", "docker", "helm"]

# Post-install hooks
[hooks]
post_setup = "echo 'Environment ready!'"

[hooks.node]
post_install = "corepack enable"

# Environment variables
[env.vars]
PROJECT_ROOT = "$PWD"
NODE_ENV = "development"

# Custom project commands (used by interactive menu)
[commands]
run = "npm start"
test = "npm test"

See Configuration Reference for all options including environment variables, secrets, services, drift detection, network/proxy settings, and git configuration.

Shell Completions

Jarvy supports tab completions for all major shells:

# Bash
jarvy completions bash >> ~/.bashrc

# Zsh
jarvy completions zsh >> ~/.zshrc

# Fish
jarvy completions fish > ~/.config/fish/completions/jarvy.fish

# PowerShell
jarvy completions powershell >> $PROFILE

Or view installation instructions for your shell:

jarvy completions --instructions

Key Commands

Run jarvy --help for the full command reference.

Use in CI/CD

GitHub Actions

jobs:
  setup:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install Jarvy
        uses: bearbinary/jarvy/.github/actions/setup-jarvy@main
        with:
          method: cargo
      - run: jarvy setup --ci

The --ci flag enables non-interactive mode with CI-provider detection (GitHub Actions, GitLab CI, CircleCI, Azure DevOps, Jenkins, Bitbucket).

Scaffold a New Tool

Contributors can add tool support using the built-in scaffolding command:

# Creates src/tools/mytool/ with the define_tool! macro template
cargo run -p cargo-jarvy -- new-tool mytool

# Or if cargo-jarvy is installed:
cargo jarvy new-tool mytool

AI/LLM Integration

Jarvy includes a built-in MCP server that lets AI agents discover, check, and install tools via JSON-RPC:

jarvy mcp

For AI agents and LLMs, see llms.txt for a structured reference optimized for machine consumption.

Documentation

• Quickstart Guide
• Configuration Reference
• CLI Reference
• Hooks
• Adding Tools
• CI/CD Integration
• MCP Server
• FAQ
• Privacy Policy

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

# Build
cargo build

# Test
cargo test --verbose -- --show-output

# Lint
cargo fmt --all && cargo clippy --all-features -- -D warnings

# Scaffold a new tool
cargo run -p cargo-jarvy -- new-tool <name>

License

Dual-licensed under MIT or Apache-2.0, at your option.

GitHub | Documentation | Report an Issue