Build automation · Deno & TypeScript

Builds you can refactor, not just run.

Zuke is a code-first, strongly-typed build system. Define targets as TypeScript class fields, wire dependencies with a fluent API, and let Zuke resolve and run them in topological order — with zero runtime dependencies.

Get started → View on GitHub
Install the CLI 
$deno install -A -g -n zuke jsr:@zuke/cli
$zuke setup
$./zuke
zuke.ts 
import { Build, run, target } from "jsr:@zuke/core";
import { DenoTasks } from "jsr:@zuke/deno";

class MyBuild extends Build {
  clean = target()
    .executes(async () => { await $`rm -rf dist`; });

  compile = target()
    .description("Type-check & bundle")
    .dependsOn(this.clean, this.restore)
    .executes(async () => {
      await DenoTasks.check((s) => s.paths("mod.ts"));
    });
}

if (import.meta.main) await run(MyBuild);
v1 on the horizon • Deno-native • Zero runtime deps • Published on JSR • Inspired by NUKE for .NET
Why Zuke

Everything a build needs — typed end to end.

Typed, refactor-safe dependencies

Targets reference each other with this.target — not magic strings. Rename one and every reference updates. The compiler has your back.

Just TypeScript

Build logic is ordinary async functions with full editor support, types, and debugging. No YAML, no bespoke DSL to learn.

Automatic topological order

Declare what each target depends on; Zuke resolves the graph and runs everything in the right order, skipping what's already done.

Ergonomic, safe shell

The $ tagged template executes processes with sensible defaults and prevents injection — capture output, ignore failures, or fail fast.

Zero runtime dependencies

Zuke ships on Deno with nothing else to install. The bootstrap launcher even installs Deno for you on first run.

A typed tool ecosystem

Strongly-typed wrappers for Deno, npm, Bun, Docker, Kubernetes, Playwright, Terraform and more — all published to JSR.

Topological resolution

Declare dependencies.
Zuke figures out the order.

Each target lists what it dependsOn. Zuke builds the dependency graph, runs independent targets as far as it can, and executes everything exactly once in the correct order.

  • References are real values — this.build, never a string.
  • Per-target status, timing, and a final build summary.
  • Rename a target and every dependant updates automatically.

↓ This is the actual graph that builds this website.

shell.ts 
// The $ tagged template runs processes safely — no shell injection.
const sha = await $`git rev-parse HEAD`.text();   // trimmed stdout
await $`deno test -A`;                              // throws on non-zero
const code = await $`flaky-cmd`.noThrow().code();   // never throws
The $ shell

Run processes without the footguns.

The $ tagged template from @zuke/core/shell escapes interpolations automatically, so untrusted values can't break out of a command. Chain .text(), .code(), or .noThrow() for exactly the behaviour you want.

Read the shell guide →
The @zuke ecosystem

Typed wrappers for the tools you already use.

Every wrapper is a fluent, strongly-typed API over a real CLI — published to JSR, tree-shakeable, and refactor-safe.

Runtimes & package managers

Install, run, and publish across every major JS toolchain.

  • Deno @zuke/deno test, check, fmt, lint, publish
  • npm @zuke/npm ci, install, run scripts, publish
  • Bun @zuke/bun install, run, bun test
  • pnpm @zuke/pnpm frozen installs, --filter workspaces
  • Yarn @zuke/yarn Classic & Berry support

Containers & orchestration

Build images and ship to clusters from a typed pipeline.

  • Docker @zuke/docker build, tag, push
  • Docker Compose @zuke/docker-compose up, down, services
  • kubectl @zuke/kubectl apply, rollout, contexts

Lint & format

Keep the tree clean with first-class linters and formatters.

  • oxlint @zuke/oxlint ultra-fast Rust linter
  • ESLint @zuke/eslint configs, --fix, caching
  • dprint @zuke/dprint pluggable formatting
  • cspell @zuke/cspell spell-check your sources

Test & browsers

Run unit and end-to-end suites with coverage wired in.

  • Jest @zuke/jest projects, coverage thresholds
  • Vitest @zuke/vitest watch, coverage, UI
  • Playwright @zuke/playwright cross-browser e2e

TypeScript runners

Execute and type-check TypeScript without a build step.

  • tsx @zuke/tsx run TS directly on Node
  • tsgo @zuke/tsgo the native Go TypeScript compiler

Cloud & infrastructure

Provision and deploy with infra-as-code, typed end to end.

  • gcloud @zuke/gcloud deploy, run, IAM
  • Terraform @zuke/terraform init, plan, apply
  • OpenTofu @zuke/tofu open-source Terraform

Version control & CI

Script Git and GitHub straight from your build.

  • Git @zuke/git tag, commit, rev-parse
  • GitHub CLI @zuke/gh releases, PRs, workflows

Supply-chain security

Scan workflows and secrets as part of the gate.

  • Security @zuke/security zizmor, actionlint, gitleaks
The engine
@zuke/core the Build base class, target() graph, and $ shell
@zuke/cli the global `zuke` command: setup, run, list
@zuke/cmd the typed process layer the wrappers are built on

Ship your first typed build in minutes.

Install the CLI, scaffold a zuke.ts, and run your first target.

$deno install -A -g -n zuke jsr:@zuke/cli
$zuke setup
$./zuke --list
Read the docs → Browse examples