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
• 235+ tools supported -- From git and docker to terraform, kubectl, and language runtimes
• Six language ecosystems -- [npm], [pip], [cargo], [nuget], [gem], [go] install language-specific packages alongside CLI tools
• AI agent integration -- Distribute guardrails ([ai_hooks]), MCP servers ([mcp_register]), and AI skills ([skills]) across Claude Code / Cursor / Codex / Windsurf / Cline / Continue from one config
• Git hooks -- [git_hooks.native] writes scripts directly into .git/hooks/ from an inline body, a local folder, or a shared team git repo — no third-party framework required
• Library registry -- Publish reusable AI hooks, MCP servers, and skills at any HTTPS URL; consumers reference by use = "name" (PRD-054)

Contributor Onboarding (Clean Laptop)

Brand-new machine, nothing installed? Two commands:

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

# 2. Clone + provision everything else
git clone https://github.com/Cliftonz/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/Cliftonz/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/Cliftonz/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/Cliftonz/jarvy/main/dist/scripts/install.sh | bash

# Windows PowerShell
$env:JARVY_CHANNEL = 'beta'
irm https://raw.githubusercontent.com/Cliftonz/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:

Channel	Accepts
stable	Only vX.Y.Z tags
beta	vX.Y.Z, vX.Y.Z-rc.N, vX.Y.Z-beta.N
nightly	Everything including -alpha.N

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, git configuration, language packages ([npm]/[pip]/[cargo]/[nuget]/[gem]/[go]), AI hooks ([ai_hooks]), MCP registration ([mcp_register]), git hooks ([git_hooks]), Windows setup knobs ([windows]), AI agent skills ([skills]), and the library registry (library_sources) pattern.

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

Command	Description
jarvy setup	Install all tools from jarvy.toml
jarvy init	Create a new config interactively or from a template
jarvy doctor	Health-check your environment
jarvy validate	Validate a jarvy.toml file
jarvy diff	Show what's installed vs. what's needed
jarvy drift check	Detect environment drift from baseline
jarvy tools	List all 200+ supported tools
jarvy templates list	Browse available project templates
jarvy completions	Generate shell completions
jarvy diagnose	Create a diagnostic bundle for support
jarvy mcp	Start the MCP server for AI agent integration
jarvy ai-hooks apply	Distribute AI agent guardrails (Claude Code / Cursor / Codex / Windsurf / Cline / Continue)
jarvy mcp-register apply	Auto-register Jarvy's MCP server with terminal AI agents so they can discover its tools

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: Cliftonz/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
• Installation
• Configuration Reference
• CLI Reference
• Hooks
• Git hooks
• Windows setup
• Adding Tools
• Language Packages
• AI Hooks
• MCP Registration
• AI Agent Skills
• Library Registry (PRD-054)
• CI/CD Integration
• MCP Server
• FAQ

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