rexrun

Posted on May 21

I built a CLI that eliminates README reading forever

#go #opensource #productivity #cli

The problem

Every developer knows this pain:

Clone a repo
Want to run the tests
Open the README
Scroll... scroll... find a "Development" section... maybe
Figure out it's pnpm test (not npm test, not yarn test)
Run it wrong anyway because you needed pnpm install first

Multiply this by every repo you touch. Every PR you review. Every onboarding.

I got tired of it.

The solution: rex

git clone https://github.com/some/repo
cd repo
rex test

That's it. Rex looks at your project files, detects the stack, and runs the correct command. No config. No setup. No reading anything.

How it works

Rex reads files in your project root:

File found	Stack detected	`rex test` runs
`go.mod`	Go	`go test ./...`
`package.json` + `pnpm-lock.yaml`	Node + pnpm	`pnpm test`
`Cargo.toml`	Rust	`cargo test`
`pyproject.toml` + `uv.lock`	Python + uv	`uv run pytest`
`composer.json` + `artisan`	PHP + Laravel	`php artisan test`
`Gemfile` + `app/`	Ruby + Rails	`bundle exec rails test`
`pom.xml`	Java + Maven	`mvn test`
`build.gradle`	Java + Gradle	`./gradlew test`
`build.zig`	Zig	`zig build test`
`mix.exs`	Elixir	`mix test`
`Makefile`	Make	`make test`
`Justfile`	Just	`just test`

12 ecosystems. It also detects which package manager you use by looking at lockfiles.

Demo

Watch the video demo

$ cd my-go-project/
$ rex

  my-go-project

  stack  go

  commands
    rex test   go test ./...
    rex run    go run ./cmd/server
    rex build  go build ./...
    rex deps   go mod download
    rex fmt    gofmt -w .
    rex lint   go vet ./...

$ rex test
> go test ./...
ok   github.com/example/app   1.2s

The > arrow always shows exactly what rex will run. Full transparency.

All the verbs

Command	What it does
`rex test`	Run tests
`rex run`	Start the app / dev server
`rex build`	Build the project
`rex deps`	Install dependencies
`rex clean`	Remove build artifacts
`rex fresh`	clean, deps, build in sequence
`rex fmt`	Format code
`rex lint`	Lint code
`rex clone <url>`	Clone + detect + install deps in one command
`rex init`	Generate rex.toml for your team
`rex doctor`	Diagnose environment issues

Killer feature: rex clone

rex clone https://github.com/someone/project
# cloning...
# detected: node + pnpm
# deps: pnpm install
# ready! cd project && rex run

From URL to working project in one command. No README needed.

Monorepo support

Rex auto-detects monorepos (packages/, apps/, services/):

$ rex

  my-monorepo (monorepo)

  workspace  3 sub-projects detected

    packages/api         node + pnpm
    packages/web         node + pnpm
    services/auth        go

Team workflow: rex init

rex init
# created rex.toml (go project)

Generates a rex.toml from detected commands. Commit it. Now every teammate runs the same commands without asking.

.env loading

Rex automatically loads .env files before running commands. No extra tools needed.

Why I built this

I maintain projects across Go, Node, Python, and Rust. I context-switch between repos dozens of times per day. The cognitive load of remembering pnpm test vs go test ./... vs cargo test is small individually, but it adds up.

Rex makes every repo feel the same:

rex test   # always works
rex run    # always works
rex build  # always works

It's the muscle memory tax I no longer pay.

Technical details

Single binary, no runtime, no dependencies
Written in Go, cross-platform
Less than 50ms startup, faster than your shell prompt
Zero network calls, fully offline
Correct exit codes, works in CI
Shell completions for bash, zsh, fish
Apache 2.0 license
Mentioned in Awesome Go

Install

# Homebrew (macOS/Linux)
brew tap rexrun-dev/tap && brew install rex

# Go
go install rexrun.dev/rex/cmd/rex@latest

Or grab a binary from GitHub Releases.

DEV Community