just-buildit

Complete project infrastructure tooling and automation.

Stand up a complete project, install its system dependencies, fetch and run its tools, build it into a wheel — all from small primitives that don't own your project. Declare what you need in TOML; the tooling pulls the rest on demand.

. <(curl -sSL https://just-buildit.github.io/get-jb.sh)   # the only curl you need

jbx install-deps                      # system packages, from bootstrap.toml
jbx just-bashit:logging log "hello"   # any script in the org, by name
jbx gh:user/repo/tool                 # or anything on GitHub, by URL

The toolchain — each piece stands alone, and they compose:

Greenfield Python+C extension — just-makeit new stands up a complete project: C source, headers, CMakeLists, Python bindings, type stubs, tests, and benchmarks — all green on the first make test. The build backend is just-buildit; the bootstrap manifest (bootstrap.toml, carrying the [tools.*] table and the system build deps under [dev.*]) is dropped in pre-populated so the next contributor lands running. You write the algorithm; nothing else.

Any project, anywhere — drop a bootstrap.toml at the repo root and run jbx install-deps. System packages for apt/pacman/brew/dnf/zypper/msys2 are detected and installed. No Python, no Docker, no setup.

One-off scripts — jbx <name> fetches, runs, and discards. Detects bash or Python from shebang/extension; Python scripts pick up PEP 723 inline dependencies through uv run. Cache TTL, checksum verification, function dispatch, sandboxed env — all there.

Namespaces — jbx [NAMESPACE:]NAME. A namespace resolves to a base URL. The default is just-buildit, served from the org-pages root with a curated aliases.toml. jbx install-deps just works; jbx gh:user/repo/tool hits GitHub raw directly.

Every repo in the org answers the same targets, because every repo vendors the same standard.mk. You do not have to read a project's Makefile to work on it:

make help          # every target, generated from the rules — never hand-listed
make setup         # one-time per clone: dependencies + the git hook
make install-deps  # system packages, from bootstrap.toml
make test          # the default suite
make lint          # the gate CI runs — and CI runs nothing else
make format        # auto-fix with every configured formatter

Adopting it is one fetch and one include. Vendor the file:

curl -fsSL https://just-buildit.github.io/standard.mk -o standard.mk

…then your Makefile is configuration only — feature flags and the commands behind them, never a copy of the shared rules:

# Makefile
TEST_CMD      = pytest
TEST_FAST_CMD = pytest -x
CLEAN_PATHS   = dist/ build/
include standard.mk

That is the whole adoption, and it is enough for make help, test, lint, format and clean. Nine feature flags add the rest — HAS_C, HAS_PYTHON, HAS_RUST, HAS_DOCS, HAS_DOXYGEN, HAS_BENCH, HAS_COVERAGE, HAS_RELEASE, HAS_EXAMPLES — and each requires the command behind it: a flag with nothing to run is a parse error, not a target that silently does nothing.

Each file owns one concern: the Makefile says how a tool runs, pyproject.toml says which version, and .pre-commit-config.yaml says when — dispatching back in with make lint-<tool> so a hook and CI cannot disagree about what a check means.

Vendoring arms a drift gate: make lint re-fetches canonical every time and fails on any difference, so the copy in your repo cannot quietly become a fork.

# Install jbx (and just-runit, the same runner's full name)
. <(curl -sSL https://just-buildit.github.io/get-jb.sh)

# Install just-makeit, then stand up a Python+C extension
# (drops a bootstrap.toml with build deps pre-populated under [dev.*])
pip install just-makeit
just-makeit new my_project --object engine --state gain:double:1.0
cd my_project

# Install those build deps for your platform (apt/pacman/brew/dnf/...)
jbx install-deps

# Build and test — green on first run
make && make test

MIT across all repos.