DEV Community: crovia

I built a GitHub Action that works with any stack — here's how

crovia — Fri, 29 May 2026 18:18:40 +0000

The problem

Every time I clone a repo, I have to figure out how to run it.

Go project? go test ./... — unless it uses make test
Node project? npm test — unless it uses pnpm or yarn or bun
Rust? cargo test. Python? Could be pytest, python -m unittest, or poetry run pytest.

This is fine for my own projects. But when I'm reviewing a PR, onboarding a new teammate, or setting up CI for a polyglot team, it becomes noise.

What I built

rex is a single Go binary that detects your project's stack and runs the right command. No config file. No reading the README.

git clone https://github.com/someone/unknown-project
cd unknown-project
rex test   # it just works

How it works under the hood

The detection logic is surprisingly simple — and that's the point.

Step 1: File scanning

rex walks your project root and looks for known files:

File	Stack	Package manager
`go.mod`	Go	go modules
`package.json` + `pnpm-lock.yaml`	Node	pnpm
`Cargo.toml`	Rust	cargo
`pyproject.toml` + `uv.lock`	Python	uv
`pom.xml`	Java	Maven
`build.gradle`	Java	Gradle
`Gemfile`	Ruby	bundler
`composer.json`	PHP	composer
`mix.exs`	Elixir	mix
`build.zig`	Zig	zig

This happens in <50ms because it's just os.Stat calls — no network, no parsing heavy files.

Step 2: Command mapping

Once the stack is known, rex maps standard verbs to the right tool:

// Go
test  -> "go test ./..."
run   -> "go run ./cmd/server"
build -> "go build ./..."

// Node (pnpm)
test  -> "pnpm test"
run   -> "pnpm run dev"
build -> "pnpm run build"

Step 3: Priority chain (the smart part)

rex doesn't blindly guess. It respects what's already there:

1. Justfile / Makefile (task runner overrides everything)
2. package.json scripts / Cargo.toml / go.mod (ecosystem native)
3. Language heuristics (fallback)

If a Makefile defines a test target, rex test runs make test — even in a Go project.

The GitHub Action

The most interesting part is how this became a GitHub Action.

Instead of requiring Go to be installed in the runner, the action downloads the correct binary directly from the release page:

- uses: rexrun-dev/rex@v0.4.0
  with:
    command: test

This single step replaces 10+ lines of stack-specific YAML. Works for all 12 supported languages.

Why composite actions?

I used GitHub's composite action type instead of Docker. Why?

Faster: no container startup
Smaller: no image to pull
Portable: works on any runner (ubuntu, macOS, Windows)

The trade-off? The install script has to handle OS/arch detection:

OS=$(uname -s | tr '[:upper:]' '[:lower:]')
ARCH=$(uname -m)
case "$ARCH" in
  x86_64) ARCH="amd64" ;;
  aarch64|arm64) ARCH="arm64" ;;
esac
URL="https://github.com/rexrun-dev/rex/releases/download/${VERSION}/rex_${VERSION#v}_${OS}_${ARCH}.tar.gz"
curl -sL "$URL" | tar xz -C /usr/local/bin rex

Watch mode

A recent addition: rex watch polls the filesystem and re-runs your command on change.

rex watch test   # re-run tests when files change
rex watch build  # re-build on change

It's not using inotify or fsnotify — just a lightweight polling loop with hash-based change detection. This makes it portable across all platforms without CGO or platform-specific dependencies.

CI generator

rex ci generates a GitHub Actions workflow file customized for your detected stack:

$ rex ci
✓ created .github/workflows/ci.yml (go project)

The generated YAML uses the official setup actions for each language (setup-go, setup-node, setup-python, etc.) and runs the correct test command.

Numbers

Binary size: ~3.5 MB
Startup time: <50ms
Languages supported: 12
Lines of Go: ~2,000
Zero runtime dependencies

Try it

brew tap rexrun-dev/tap && brew install rex
# or
go install rexrun.dev/rex/cmd/rex@latest

Or try the interactive playground at rexrun.dev — paste any GitHub repo URL and see what rex would detect.

GitHub: github.com/rexrun-dev/rex
Marketplace: github.com/marketplace/actions/rex-universal-project-runner

I built a CLI that eliminates README reading forever

crovia — Thu, 21 May 2026 16:02:26 +0000

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: crovia

I built a GitHub Action that works with any stack — here's how

The problem

What I built

How it works under the hood

Step 1: File scanning

Step 2: Command mapping

Step 3: Priority chain (the smart part)

The GitHub Action

Why composite actions?

Watch mode

CI generator

Numbers

Try it

I built a CLI that eliminates README reading forever

The problem

The solution: rex

How it works

Demo

All the verbs

Killer feature: rex clone

Monorepo support

Team workflow: rex init

.env loading

Why I built this

Technical details

Install

Links