rhow

Open-source CLI · MIT · Rust

Understand how to run any repository.

rhow, short for run how, is a tiny CLI that discovers how a project is meant to be run, so you don't have to dig through README files, Makefiles, package scripts and configuration.

Install rhow View on GitHub

Try it: click the terminal and type rhow, rhow --group or rhow --ci.

Every repository has its own way of running.

The commands are written down somewhere. Which file, which tool, which name and which ones are safe to run: that is the part you dig for.

Stop hunting for the right command.

How it works

  1. Enter a repository

    Any checkout. Zero configuration, nothing to install into the project.

    $ cd unfamiliar-project

  2. Run rhow

    One read-only pass over the files the project already has. Milliseconds.

    $ rhow

  3. See how it runs

    The exact native command, what it does, and whether it is long-running, external or destructive.

    unfamiliar-project  [Go, Docker]

  go run .                       Run Go server program
  go test ./...                  Run Go tests
  go vet ./...                   Check Go source with go vet
  docker compose up -d postgres  Start PostgreSQL
  docker compose down            Stop and remove Docker services

When you reach for rhow

There are more repositories than ever and each one is a little different. The first question is always the same: how do I run this?

  • More projects, bigger monorepos

    AI-assisted development multiplies the number of projects a person touches and the size of the monorepos they live in. Remembering how each one starts, builds and tests does not scale. Reading it in one command does.

  • Switching between codebases

    Personal projects, company repositories, a service you last opened six months ago. rhow answers before you open the README, and shows the exact native command with its risk label.

  • Staff engineers across stacks

    Fluent in the technology, new to this particular codebase. Get the pnpm filter, the Cargo workspace member or the Compose service name without reading the whole Makefile first.

  • Interviews and take-home assignments

    Cloning a starter repository for a home assignment, or reviewing a candidate's submission: see how it runs, tests and lints in one command, before anything executes on your machine.

  • Code review and open source

    Check out a pull request, a fork or a new dependency and know what its scripts do, which ones talk to the network and which ones delete data, before you run any of them.

  • Editors, scripts and agents

    rhow --json gives tools the same normalised model: every action, its command, category, risk and notes, with paths relative to the repository root.

Works with your stack

Built to understand the tools developers already use. Each ecosystem below has a fixture in the repository and is checked against real open-source products before a release.

  • JavaScript / TypeScriptnpm · pnpm · Yarn · Bun · workspaces
  • MonoreposNx · Turborepo · Rush · moon
  • Denodeno.json tasks
  • Pythonuv · Poetry · PDM · Pipenv · tox · nox · Django
  • Gogo.mod · go.work · cmd/*
  • RustCargo · workspaces · aliases
  • Ruby / RailsRake · bin/dev · RSpec · Minitest
  • PHPComposer · Laravel · Artisan
  • .NETsolutions · projects · EF Core · Cake · NUKE
  • JVMGradle · Maven · Scala / sbt · Clojure
  • MobileSwift / Xcode · Flutter · Expo · React Native · Fastlane
  • NativeCMake · Zig · Bazel · Haskell · Elixir / Mix
  • Task runnersMake · Just · Taskfile
  • DockerDockerfile · Compose services
  • KubernetesHelm · Kustomize · manifests · Skaffold
  • InfrastructureTerraform · Terragrunt · Pulumi · Ansible
  • CIGitHub Actions · GitLab CI
  • VersionsNode · Go · Rust · Python · Ruby · PHP · Terraform · Gradle · Bazel

Command analysis recognises well over a hundred tools inside those files: Vite, Next, Vitest, Jest, Playwright, ESLint, Prettier, tsc, Prisma, Drizzle, pytest, Ruff, mypy, uvicorn, kubectl, helm, terraform, docker compose and more. Full table in the README.

Read the repository.
Don't run it.

rhow inspects project files and discovers commands. It never executes a project command, never spawns npm, cargo or kubectl to ask them questions, never touches the network, and never writes to the checkout. Explanations come from a static knowledge table and a deterministic tokenizer: same input, same output, offline, in milliseconds. You run the command yourself, with the project's own tool.

  • LocalRuns entirely on your machine.
  • Read-onlyA test guards that discovery never writes.
  • No setupNo .rhow.yml, ever.
  • No API keysNo LLM, no account, no telemetry.
  • No cloud dependencyNever contacts a registry or a cluster.
  • No command executionShows the command. You run it.

One binary, a few flags

Everything below is real output from rhow's own fixture repositories.

rhow lists the useful commands of every project in the repository, in the order the project declares them. Nothing is hidden: what one tool already covers is simply not repeated.

$ rhow

storefront  [Node.js, Docker, Turborepo, Playwright, PostgreSQL]

  pnpm run dev                   Run dev across packages with Turborepo  ∞ long-running
  pnpm run build                 Run build across packages with Turborepo
  pnpm run test                  Run test across packages with Turborepo
  pnpm run lint                  Run lint across packages with Turborepo
  pnpm run typecheck             Run typecheck in all workspace packages
  pnpm run services              Start postgres and redis services in background
  pnpm run e2e                   Run Playwright end-to-end tests
  docker compose up -d           Start all Docker services
  docker compose up -d postgres  Start PostgreSQL
  docker compose up -d redis     Start Redis
  docker compose up -d orders    Start orders service (built from source)
  docker compose up -d payments  Start payments service (built from source)
  docker compose logs -f         Follow Docker service logs  ∞ long-running
  docker compose build           Build Docker service images
  docker compose down            Stop and remove Docker services
  docker compose down -v         Stop Docker services and delete their volumes  ● destructive

apps/bff  [Node.js, NestJS, Jest, Prisma]
  pnpm run dev         Start NestJS app in watch mode  ∞ long-running
  pnpm run build       Build NestJS app
  pnpm run start       Run dist/main
  pnpm run test        Run Jest tests
  pnpm run test:e2e    Run Jest tests
  pnpm run lint        Check source code with ESLint
  pnpm run typecheck   Check TypeScript types
  pnpm run db:migrate  Apply pending Prisma migrations
  pnpm run db:reset    Reset database and re-apply migrations  ● destructive

apps/mobile  [Node.js, Expo, Jest]
  pnpm exec expo prebuild  Generate native iOS and Android projects
  pnpm exec expo-doctor    Check Expo project for common issues
  pnpm run start           Start Expo development server  ∞ long-running
  pnpm run ios             Build and run app on iOS  ∞ long-running  ⊙ device
  pnpm run android         Build and run app on Android  ∞ long-running  ⊙ device
  pnpm run test            Run Jest tests
  pnpm run lint            Check source code with ESLint

apps/web  [Node.js, Next.js, Vitest, Playwright]
  pnpm run dev        Start Next.js development server  ∞ long-running
  pnpm run build      Build Next.js app
  pnpm run start      Start Next.js production server  ∞ long-running
  pnpm run test       Run Vitest tests
  pnpm run test:e2e   Run Playwright end-to-end tests
  pnpm run lint       Check source code with ESLint
  pnpm run typecheck  Check TypeScript types

packages/ui  [Node.js, Vitest]
  pnpm run build  Build package with tsup
  pnpm run test   Run Vitest tests
  pnpm run lint   Check source code with ESLint

services/orders  [Go]
  go build ./...     
  go test ./...        Run Go tests
  go vet ./...         Check Go source with go vet
  go fmt ./...         Format Go source
  go mod tidy          Tidy Go module dependencies  ↓ download
  go run ./cmd/orders  Run orders command

services/payments  [Go]
  go build ./...       
  go test ./...          Run Go tests
  go vet ./...           Check Go source with go vet
  go fmt ./...           Format Go source
  go mod tidy            Tidy Go module dependencies  ↓ download
  go run ./cmd/payments  Run payments command
  • rhow path/to/dirinspect exactly that directory
  • rhow --color neverplain output; NO_COLOR is honoured
  • rhow --no-runtimeskip local runtime suggestions

Install

A single static binary for macOS, Linux and Windows. The installer detects your OS and CPU, downloads the matching GitHub release, verifies its SHA256, and installs to ~/.local/bin without sudo.

curl -fsSL https://raw.githubusercontent.com/euzharkov/run-how/main/install.sh | sh
  • Homebrew
    brew install euzharkov/tap/rhow
  • Cargo
    cargo install rhow
  • cargo-binstall
    cargo binstall rhow
  • npm
    npx @euzharkov/rhow
  • WinGet
    winget install euzharkov.rhow
  • Scoop
    scoop install rhow

Prebuilt binaries for macOS (arm64, x64), Linux (arm64, x64, musl) and Windows (arm64, x64), with a SHA256SUMS file, on GitHub Releases. AUR and Nix packaging live in the repository. View installation instructions

Questions

What does rhow stand for?

run how. You open a repository and ask how to run it. rhow answers with the commands the project already defines.

Does rhow execute anything?

No. Discovery reads files and nothing else: it never runs a project script, never spawns npm, cargo, docker or kubectl, never installs dependencies and never touches the network. A test in the repository guards that it stays read-only. You run the command with the project's own tool.

How is it different from make, just or Task?

Those run tasks you write for them. rhow reads them, together with package.json, Cargo.toml, pyproject.toml, Compose files, Kubernetes manifests and CI pipelines, and shows what is there in one list. It never replaces the project's own tool and it is not a task runner.

Does it need a config file, an account or an API key?

No. There is no .rhow.yml, no account, no LLM and no telemetry. Explanations come from a static knowledge table, so the same repository gives the same output, offline, in milliseconds.

Does it work in monorepos?

Yes. Workspace packages and nested projects are listed by path with the right filter command, for example pnpm --filter api test. Repeated scripts and inherited Nx targets are shown once instead of once per package, so the list stays the commands a developer would type, with nothing hidden.

Which platforms are supported?

Prebuilt binaries for macOS (arm64, x64), Linux (arm64, x64, musl) and Windows (arm64, x64), plus Homebrew, Cargo, npm, WinGet, Scoop, AUR and Nix packaging.

Built in the open.

Rust, MIT licensed, no dependencies you would not add yourself. Fixture snapshots are the specification; every behaviour change is visible in a diff. Bugs, ecosystems and ideas are welcome.

github.com/euzharkov/run-how

View on GitHub