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.

README.md
Makefile
package.json
pyproject.toml
Cargo.toml
Dockerfile
compose.yaml
Taskfile.yml
justfile
go.mod
Gemfile
.github/workflows/ci.yml
pnpm-workspace.yaml
Chart.yaml

$ rhow

my-app  [Node.js, Vite, Vitest, Prisma, Playwright]

  npm run dev          Start Vite development server  ∞ long-running
  npm run build        Compile TypeScript sources, then build app with Vite
  npm run test         Run Vitest tests
  npm run lint         Check source code with ESLint
  npm run db:migrate   Apply pending Prisma migrations
  npm run db:reset     Reset database and re-apply migrations  ● destructive

Stop hunting for the right command.

How it works

01

Enter a repository

Any checkout. Zero configuration, nothing to install into the project.
```
$ cd unfamiliar-project
```
02

Run rhow

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

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 --group orders each project's commands by type: run, build, deploy, test, quality, database and so on.

$ rhow --group

npm-basic  [Node.js, Vite, Vitest, Prisma, Playwright]

  npm run dev          Start Vite development server  ∞ long-running
  npm run preview      Preview production build with Vite  ∞ long-running
  npm run start        Run dist/server.js

  npm run build        Compile TypeScript sources, then build app with Vite
  npm run clean        Delete dist and coverage
  npm run nuke         Delete ~/.cache/thing  ● destructive

  npm run deploy         ● external
  npm run release      Publish package to npm  ● external

  npm run test         Run Vitest tests
  npm run test:e2e     Run Playwright end-to-end tests
  npm run test:watch   Run Vitest tests in watch mode  ∞ long-running

  npm run lint         Check source code with ESLint
  npm run lint:fix     Fix lint issues with ESLint
  npm run typecheck    Check TypeScript types
  npm run format       Format source code with Prettier
  npm run check        Run linting, type checks, and tests
  npm run pretest      Check source code with ESLint

  npm run db:migrate   Apply pending Prisma migrations
  npm run db:reset     Reset database and re-apply migrations  ● destructive

  npm run xyz          Regenerate icon sprite
  npm run prepare      Install Git hooks with Husky  ∆ git
  npm run postinstall  Apply local dependency patches

rhow --ci shows GitHub Actions and GitLab CI as the structure they are: workflow, trigger, jobs, then each step with the same explanation, risk and notes. Nothing is evaluated.

$ rhow --ci

CI  .github/workflows/ci.yml  on push main, pull_request
  Test  ubuntu-latest
    npm ci                        Install dependencies with npm  ↓ download
    npm test                      Run Vitest tests
    npm run build …               Build app with Vite, then run Playwright end-to-end tests
  deploy  ubuntu-latest
    npx wrangler deploy           Deploy Cloudflare Worker  ● external

GitLab CI  .gitlab-ci.yml
  unit  test
    npm ci     Install dependencies with npm  ↓ download
    npm test   Run Vitest tests
  pages  deploy
    npx wrangler deploy   Deploy Cloudflare Worker  ● external

rhow --json emits the normalised model for editors and scripts: exactly the actions the listing shows, paths relative to root. Also rhow --ci --json and rhow support --json.

$ rhow --json

{
  "schema": 2,
  "version": "0.1.0",
  "root": "/home/you/npm-basic",
  "name": "npm-basic",
  "projects": [
    {
      "name": "npm-basic",
      "path": ".",
      "kind": "java-script",
      "tools": [
        "npm",
        "sh"
      ],
      "techs": [
        "Node.js",
        "Vite",
        "Vitest",
        "Prisma",
        "Playwright"
      ],
      "actions": [
        {
          "id": "dev",
          "name": "dev",
          "description": "Start Vite development server",
          "command": "npm run dev",
          "working_directory": ".",
          "source": "declared",
          "confidence": "exact",
          "risk": "safe",
          "category": "development",
          "tool": "npm",
          "notes": [
            "long-running"
          ],
          "opaque": false
        },
        …
      ]
    }
  ]
}

rhow support reads the versions a repository declares (a Cargo edition, engines.node, required_version, a Gradle wrapper, …) and compares them with what this build was verified against. Static, offline, and "unclear" beats a guess.

$ rhow support

Toolsets this build of rhow has been verified against
  Rust / Cargo  editions 2015-2024
  Go            up to Go 1.26
  .NET          net5.0-net10.0
  Python        up to Python 3.14
  Node.js       up to Node 24
  pnpm          up to pnpm 10
  Terraform     up to Terraform 1.13
  Gradle        up to Gradle 9.1
  …

Detected in version-drift
  Terraform  >= 2.0   terraform/main.tf  [newer than verified]
  Bazel      9.0.0    .bazelversion  (bazel)  [newer than verified]
  Go         1.28     go.mod  (go)  [newer than verified]

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

Understand how to run any repository.

Every repository has its own way of running.

How it works

Enter a repository

Run rhow

See how it runs

When you reach for rhow

More projects, bigger monorepos

Switching between codebases

Staff engineers across stacks

Interviews and take-home assignments

Code review and open source

Editors, scripts and agents