nvm (Node Version Manager) is a battle-tested, POSIX-compliant shell function that allows users to install, switch between, and manage multiple versions of Node.js and io.js on a per-shell basis. The core architecture is a single monolithic shell script (`nvm.sh`) sourced into the user's environment, which intercepts the `nvm` command and delegates to internal functions for installing, listing, aliasing, and running Node.js versions. Key entry points include `nvm.sh` (the main script), `install.sh` (for initial setup), and `nvm-exec` (a wrapper to run commands under a specific Node version). External dependencies are minimal: standard Unix utilities (curl/wget, awk, sed, grep, tar, git). Data flows involve fetching version index files from nodejs.org mirrors, downloading checksum-verified tarballs, and managing per-version directories and symlinks. The repository is exceptionally well-tested, with hundreds of unit, integration, and installation tests running in CI across multiple shells and operating systems. Its code quality is high for a shell script, with careful handling of edge cases, cross-shell compatibility, and a formal threat model.
mise is a unified CLI tool for managing development environments. It combines tool version management (like asdf), environment variable injection, task running, dotfiles management, system package bootstrapping, and OCI image building into a single command-line interface. The system is implemented in Rust as a workspace of multiple crates, with a plugin system based on Lua (vfox) and support for many backends (asdf, aqua, npm, cargo, pipx, Homebrew, etc.). It also includes supply-chain security features via Sigstore attestation verification and packslip signing. The architecture is a modular Rust CLI with async I/O (tokio), a plugin system for tool backends, a configuration layer that merges TOML files with environment variables, and a task runner with dependency graphs and file watching. Key entry points include the main binary (src/main.rs), CLI subcommands in src/cli/, backend implementations in src/backend/, and the Lua plugin runtime in crates/vfox/. External dependencies include GitHub API, npm registry, aqua registry, Sigstore TUF repositories, and various system package managers (apt, brew, dnf, etc.). The codebase demonstrates high craftsmanship with clean abstractions (Backend trait, TaskFileProvider, SingleReport), reusable utility crates (mise-util, mise-dotenv, mise-cache-core), and extensive testing (unit, integration, e2e). Notable subsystems include an interactive TOML editor with undo support, a comment-preserving document parser, a remote cache protocol with OIDC authentication, and a documentation showreel generator with custom animation and audio. The project is actively maintained with frequent commits, comprehensive CI/CD, and a large community (34k+ stars).
NVM for Windows is a Node.js version manager for Windows, providing CLI, shim/link mode, background sync, and Windows-native integrations (Event Log, Registry, Notifications). The repository contains the build system, installer (Inno Setup with extensive Pascal scripting), and a Zig-based elevated migration helper. The actual application logic (CLI, shim, sync) resides in separate submodules (cli, shim, sync, common) not included in this analysis. The visible code demonstrates high craftsmanship: the installer handles complex migration from v1, ACL hardening, silent install policies, and scheduled task management. The Zig updater is a clean, self-contained elevated cleanup tool. The build scripts are well-structured PowerShell with parameterized steps and CI/CD integration. The project is actively maintained with a recent v2 rewrite, modern CI workflows, and a large user base.
Xcodes is a command-line tool for installing, managing, and switching between multiple versions of Apple's Xcode IDE. It provides subcommands for downloading, listing, selecting, uninstalling, and updating Xcode releases, as well as managing simulator runtimes. The tool supports two data sources: scraping Apple's Developer downloads page (the 'apple' source) and consuming the unofficial Xcode Releases JSON feed ('xcodeReleases'). Authentication is handled through Apple ID with two-factor or SMS fallback, or via fastlane session cookies. The architecture is a modular Swift Package Manager project with a thin CLI entry point (using Apple's ArgumentParser) and a core library (XcodesKit) that encapsulates all business logic. The core library uses a lightweight dependency injection pattern via an Environment struct, a strategy pattern for downloads (URLSession or aria2), and a service-oriented design for runtime installation, list management, and system configuration. The codebase exhibits strong Swift concurrency adoption and includes test fixtures for parsing Apple HTML and property-list data. While the Apple scraping approach is inherently fragile, the overall architecture is well-structured, testable, and follows modern Swift best practices.
asdf is a command-line application that manages multiple runtime versions (Node.js, Python, Ruby, etc.) per project using a plugin architecture. The Go binary dispatches commands like install, set, current, exec, and reshim; it reads `.tool-versions` files searched from the current directory upward, resolves versions via environment variables, plugin callbacks, and legacy version files, then invokes plugin-provided Bash scripts for listing, downloading, and installing tools. It generates shim executables that proxy to `asdf exec` at runtime, and supports shell completions, hooks, and extension commands. Architecturally, asdf is a modular single-binary Go application with internal packages for plugins, versions, shims, resolution, configuration, Git operations, execution, and plugin index lookups. Key external runtime dependencies are bash (plugin callbacks and hooks), git (plugin repository cloning/updating), and the asdf-plugins index. The codebase reflects a rewrite from Bash to Go (v0.16+), preserving the plugin extension model while introducing typed errors, interfaces, and more maintainable package boundaries. Some legacy BATS integration tests and in-progress cleanup comments remain, but the core implementation is clean and well-organized.
tfenv is a command-line Terraform version manager written in Bash, modelled after rbenv. It provides a `terraform` shim that intercepts invocations and selects the appropriate Terraform binary based on a `.terraform-version` file, the `TFENV_TERRAFORM_VERSION` environment variable, or the default version file under `TFENV_CONFIG_DIR`. The repository implements full version lifecycle operations: install (download, verify SHA256 and optional PGP signatures, unzip), switch (`use`), uninstall (including multiple versions), list local and remote versions, pin current version, and a `min-required`/`latest-allowed` resolver that reads `required_version` constraints from `.tf` files. Architecturally it follows the rbenv pattern: a dispatcher (`bin/tfenv`), a shim (`bin/terraform`), shared libraries in `lib/` (logging, version-file discovery, version-name resolution, execution), and standalone subcommand scripts in `libexec/` that each include boilerplate to resolve `TFENV_ROOT`. The code deliberately avoids shellcheck and additional dependencies, maintaining portability across Linux, macOS, and Windows (git-bash). An extensive integration test suite downloads real Terraform binaries, and CI covers a broad OS matrix plus Docker validation. The codebase demonstrates solid engineering practice for a Bash project: clean separation of concerns, a capable logging library (`lib/bashlog.sh`) that supports file, JSON, syslog and coloured console output; careful handling of cross-platform differences (BSD vs GNU grep, CRLF line endings, ARM architecture detection); and a concurrency-safe install lock using atomic `mkdir`. Notable weaknesses are intentional boilerplate duplication across `libexec/` scripts, a test runner that historically exits 0 on failure (documented as a known bug being fixed), and regex-based HCL constraint parsing that is functional but fragile. A proposed ADR outlines a future Go edition, but the Bash implementation remains canonical.
This is an asdf plugin for managing Node.js versions. It provides commands to install, list, and resolve Node.js versions using node-build under the hood. The plugin supports legacy version files (.nvmrc, .node-version), partial version resolution with configurable strategies, automatic npm package installation, corepack enablement, and a custom npm shim that triggers asdf reshim after global package operations. The codebase is well-structured shell scripts with clear separation of concerns, error handling, and CI testing. It is actively maintained and follows asdf plugin conventions.
This is a CLI tool for installing multiple Ruby implementations (CRuby, JRuby, TruffleRuby, mruby) from source. It auto-detects the operating system, package manager, and downloader, then downloads, verifies checksums, applies patches, compiles, and installs the Ruby. The architecture is a collection of sourced bash scripts organized into a plugin system: each Ruby implementation has its own `functions.sh` and `dependencies.sh` that override generic steps. The main entry point is `bin/ruby-install`, which orchestrates the process using utility functions from `share/ruby-install/`. The codebase is well-structured with extensive test coverage using shunit2, and follows a strict coding style. It does not handle data pipelines or analytics; it is purely a system administration tool.