Vibeleaderboard
← Back to Tools
Index / tool

Devkit

https://github.com/block/devkit
Visit github.com
Category
Developer Tools
Rank
No. 1814Tools index

Previous survey · No. 1822 ·

Pricing
Open Source
Type
TOOL
Builder
block
GitHub
3 stars
Date

About

Universal build tool that detects project build systems and runs build, test, lint, and format operations against changed files only.

What it does

Devkit’s kit executable gives developers one command vocabulary across several repository types. It finds the repository root through Git, gathers committed, staged, unstaged, and untracked changes, then translates user intent into backend-specific commands. Users can also name directories or files explicitly and inspect the detected backend.

Why it's ranked here

The core idea is useful, and the implementation handles Git state more carefully than a thin command wrapper. Bazel and Go receive meaningful target selection. JavaScript support is less convincing because plain projects run repository-wide scripts, while orchestrator handling does not consistently honor the selected base branch. This is promising but uneven across backends.

What's good

Git change collection covers branch commits, staged edits, unstaged edits, and untracked files, then deduplicates them. Bazel queries reverse dependencies and falls back to the nearest package when that query fails. Go narrows work to changed package trees and recognizes dependency metadata changes. Explicit paths are rejected when they escape the repository root.

Tradeoffs

For plain pnpm or Yarn projects, changed-file selection collapses to the repository root and runs ordinary scripts. The configurable base branch is not forwarded to Nx or Turbo, and Turbo uses a fixed remote main branch filter. JavaScript builds always install dependencies first. Bazel linting and formatting quietly succeed without doing work when buildifier is unavailable.

How to use it well

Use Devkit for a branch-focused developer loop in repositories built with Bazel, pnpm, Yarn, or Go, especially when consistent commands reduce mental overhead. Verify each backend’s targeting behavior before adopting it as a required gate. It does not replace CI orchestration, support arbitrary build systems, or provision required tools such as linters and formatters.

Technical notes+

src/main.rs defines the Clap CLI, canonicalizes the repository root, rejects explicit paths outside it, and selects the first matching backend returned by all_backends(). src/git.rs computes a merge base and unions branch, staged, unstaged, and untracked paths in a BTreeSet. src/backend/bazel.rs uses rdeps(//..., set(...)), collapses results to package-wide :all labels, and falls back to ancestor BUILD discovery. src/backend/go.rs maps changed Go and module files to recursive package labels. src/backend/js.rs always returns the repository root from affected_targets(), delegates affected selection to Nx, and gives Turbo a hard-coded ...[origin/main] filter. src/backend/go_test.rs and src/backend/bazel_test.rs cover target mapping and package deduplication, but the supplied tree contains no corresponding JavaScript or Git tests.

Observed

License
Apache License 2.0
Primary language
Rust, packaged with Cargo
Interface
Command-line executable named kit with build, test, lint, fmt, and detect subcommands
Installation
Install through Hermit or build from source with Cargo
Supported backends
Bazel, pnpm, Yarn, and Go
JavaScript orchestration
Detects Nx and Turbo configuration, otherwise runs package-manager scripts directly
Test structure
Inline Rust test modules cover Go target selection and Bazel package deduplication; no JavaScript or Git test files appear in the supplied tree

Read from README.md, Cargo.toml, src/main.rs, src/git.rs, src/backend/go.rs, src/backend/js.rs, src/backend/mod.rs, src/backend/bazel.rs, src/backend/go_test.rs, src/backend/bazel_test.rs, LICENSE, Justfile, CODEOWNERS, lefthook.yml, rustfmt.toml.

What it can do

  • Detect project build system

    Software project directory → Identified build system type

  • Build changed files only

    Modified source files → Compiled artifacts

  • Run tests on changed files

    Modified test files and source files → Test results and pass/fail status

  • Lint changed files

    Modified source files → Code quality issues and warnings

  • Format changed files

    Modified source files → Formatted code files

  • Run universal build operations

    Project with any supported build system → Build, test, lint, and format results

Tags

build-toolmonorepoclirustblock

Tech Stack

Rust

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.