install-tool

name	install-tool
description	Use when a tool, CLI, or package is needed but not installed, or when the user asks to install/add a tool. Prefers mise for all installations.
argument-hint	[tool[@version] | package-name...]
model	haiku
allowed-tools	["Bash(mise search:*)","Bash(mise registry:*)","Bash(mise ls-remote:*)","Bash(mise tool:*)","Bash(mise ls:*)","Bash(mise backends:*)","Bash(mise use --dry-run:*)","Bash(mise which:*)","Bash(which:*)","Bash(command -v:*)","Bash(chezmoi source-path:*)","Bash(pwd:*)","Bash(realpath:*)","Read","Glob","Grep"]

Install Tool

This skill is the sanctioned install path. The block-adhoc-installers hook denies ad-hoc installers (npx, pipx, pip install, npm -g, brew/gem/cargo/go install, …) and redirects here, so tools stay captured in mise and the dotfiles.

Arguments

$ARGUMENTS

Instructions

1. Identify the Tool

Parse the arguments for tool names and optional versions. If no version is specified, default to @latest.

2. Check If Already Installed

mise which <tool> 2>/dev/null || command -v <tool> 2>/dev/null

If the tool is already available, report its location and version. Stop unless the user explicitly wants a different version.

3. Search the Mise Registry

mise search <tool>
mise registry <tool>

• mise search — fuzzy-searches the registry for matching tools
• mise registry <tool> — shows the full backend path (e.g., core:node, aqua:jqlang/jq)

If no results, check alternate names or ask the user.

4. Choose Scope

CRITICAL: Global installs must happen in dotfiles

Before proceeding, determine if this is a global install:

• Arguments include --global or -g
• User explicitly asks for global install
• Tool is general-purpose (jq, ripgrep, etc.) and no local mise.toml exists

If global install is requested:

1. Check if we're in the chezmoi source directory:

chezmoi_source=$(chezmoi source-path 2>/dev/null)
current_dir=$(pwd)
# Check if current directory is within chezmoi source directory

2. If NOT in dotfiles (current dir not within chezmoi source-path):

   • REFUSE the install
   • Tell the user: "Global tool installs must be done from your dotfiles repository to ensure they're tracked and reproducible. Please run chezmoi cd first, then run /install-tool again."
   • Stop execution

3. If in dotfiles:

   • Proceed with mise use --global
   • This will update home/dot_config/mise/config.toml (the chezmoi source file)
   • Remind user to apply changes: chezmoi apply ~/.config/mise/config.toml

Decision tree for project-local installs:

• Inside a project directory with mise.toml → project-local (default)
• No mise.toml exists → create one with mise use <tool>@<version>

5. Preview the Install

Always dry-run first:

mise use --dry-run <tool>@<version>

Report what will be installed and where the config will be written.

6. Execute

# Project-local (default)
mise use <tool>@<version>

# Global (only from within dotfiles)
mise use --global <tool>@<version>
# Then apply via chezmoi:
chezmoi apply ~/.config/mise/config.toml

# Pinned exact version (project-local)
mise use --pin <tool>@<version>

After global install, remind the user that the tool is now configured in their dotfiles and will be available everywhere after chezmoi apply.

7. Verify

mise which <tool>
<tool> --version  # or equivalent

Confirm the tool is available and report the installed version.

When Mise Cannot Provide the Tool

If mise search and mise registry return no results:

1. Stop and tell the user — do not fall back to brew/apt/npm/pipx
2. Suggest alternatives:
   • Check if it's available via a different name
   • Use ubi backend: mise use ubi:owner/repo
   • Use aqua backend: mise use aqua:owner/repo
   • Use language-specific backend (see reference below)
3. If mise truly cannot provide it, ask the user for approval before using any other installer

Mise Discovery Subcommands

Command	Purpose
mise search <name>	Fuzzy-search the tool registry
mise registry <name>	Show full backend path for a tool
mise registry --backend <be>	List all tools for a specific backend
mise ls-remote <tool>	List available versions for a tool
mise ls-remote <tool>@<prefix>	Filter versions by prefix (e.g., node@20)
mise tool <name>	Show info: backend, installed/active versions, config source
mise ls	List all installed and active tool versions
mise backends ls	List all available backends

Mise Backends Reference

Backend	Prefix	Installs from	Example
core	core:	Built-in support (node, python, go, etc.)	mise use node@22
aqua	aqua:	aqua registry — GitHub releases	mise use aqua:jqlang/jq
asdf	asdf:	asdf plugin ecosystem	mise use asdf:mise-plugins/mise-poetry
cargo	cargo:	Rust crates (crates.io)	mise use cargo:ripgrep
go	go:	Go modules	mise use go:golang.org/x/tools/gopls
npm	npm:	npm packages	mise use npm:prettier
pipx	pipx:	Python packages (isolated envs)	mise use pipx:black
gem	gem:	Ruby gems	mise use gem:rubocop
ubi	ubi:	GitHub releases (universal)	mise use ubi:BurntSushi/ripgrep
vfox	vfox:	vfox plugin ecosystem	mise use vfox:version-fox/vfox-node
conda	conda:	Conda/mamba packages	mise use conda:scipy
dotnet	dotnet:	.NET tools	mise use dotnet:fantomas
spm	spm:	Swift packages	mise use spm:nicklockwood/SwiftFormat
http	http:	Direct URL download	mise use http:https://example.com/tool.tar.gz

Backend Selection Guide

1. Check mise search first — most tools have a default backend
2. Core for major languages (node, python, ruby, go, java, etc.)
3. Aqua for most CLI tools distributed as GitHub releases
4. npm/pipx/cargo/go/gem for language-ecosystem packages
5. ubi as a fallback for any GitHub release not in aqua

Examples

/install-tool jq                      → search, preview, install jq
/install-tool node@22                 → install Node.js 22.x
/install-tool --global ripgrep        → install ripgrep globally
/install-tool terraform jq go         → install multiple tools
/install-tool cargo:stylua            → install via cargo backend
/install-tool ubi:BurntSushi/ripgrep  → install via ubi backend