jake 12.x

Complete instructions

Verified against jake@12.10.1 on 2026-09-08. 7 of 7 examples executed.

jake

Version and import

This skill targets jake ^12.0.0, including the documented 12.10.1 release. The package’s main entry point is lib/jake.js, and importing it returns the Jake object. The package requires Node >=10.

Use the package directly in a script:

import assert from "node:assert/strict";
import jake from "jake";

assert.equal(typeof jake.task, "function");
assert.equal(typeof jake.file, "function");
assert.equal(typeof jake.namespace, "function");
assert.equal(typeof jake.series, "function");

The documented task-definition functions include task, rule, directory, file, desc, namespace, complete, fail, packageTask, publishTask, npmPublishTask, testTask, setTaskTimeout, setSeriesAutoPrefix, and series.

Define ordinary tasks

The established API is task(name, [prerequisites], [action]). The action can be an ordinary function, an async function, or a function returning a Promise. Define prerequisites by name when they must run before the action.

import assert from "node:assert/strict";
import { desc, task } from "jake";

let ran = false;

desc("A task defined by an embedded Jake program.");
task("prepare", () => {
  ran = true;
});
task("build", ["prepare"], async () => {
  assert.equal(ran, false);
  await Promise.resolve();
});

assert.equal(typeof task, "function");
assert.equal(typeof desc, "function");

Defining a task does not, by itself, demonstrate CLI execution or prerequisite execution. Those behaviors require Jake’s runner.

File and directory tasks

Use file for a file-oriented task and directory for a directory-oriented task. A file task accepts a name, optional prerequisites, and an action. A directory task can be declared with its directory name.

import assert from "node:assert/strict";
import { desc, file } from "jake";

let actionDefined = false;

desc("Build a production file.");
file("foo-production.js", ["bar", "foo-bar.js", "foo-baz.js"], () => {
  actionDefined = true;
});

assert.equal(actionDefined, false);
assert.equal(typeof file, "function");

The file action is associated with the task definition; it is not run merely because the definition is imported.

import assert from "node:assert/strict";
import { desc, directory } from "jake";

desc('Declare the directory task "bar".');
directory("bar");

assert.equal(typeof directory, "function");
assert.equal(typeof desc, "function");

Namespaces

Use namespace(name, callback) to group task definitions. Tasks declared inside the callback are namespace-scoped, such as foo:bar in the documented shape.

import assert from "node:assert/strict";
import { desc, namespace, task } from "jake";

let defined = false;

namespace("foo", () => {
  desc("The foo:bar task.");
  task("bar", () => {
    defined = true;
  });
});

assert.equal(defined, false);
assert.equal(typeof namespace, "function");

The callback defines the task; it does not execute the task action.

Compose functions with series

series composes functions for sequential execution. The documentation labels this API experimental.

import assert from "node:assert/strict";
import { series } from "jake";

const events: string[] = [];
const clean = () => {
  events.push("clean");
};
const lint = async () => {
  events.push("lint");
};
const build = () => {
  events.push("build");
};

const composed = series(clean, lint, build);
assert.equal(typeof composed, "function");

await composed();
assert.deepEqual(events, ["clean", "lint", "build"]);

Because this API is experimental, prefer the established task form when task-definition compatibility is the priority.

Exported-function task shape

Jake also documents an alternative, experimental form in which exported functions implicitly become tasks:

import assert from "node:assert/strict";
import { series } from "jake";

function clean() {}
async function lint() {}
function internalBuild() {}

const exportedTasks = {
  clean,
  lint,
  build: series(clean, lint, internalBuild),
};

assert.equal(typeof exportedTasks.clean, "function");
assert.equal(typeof exportedTasks.lint, "function");
assert.equal(typeof exportedTasks.build, "function");

The exported-function task API and series are documented as experimental. Do not confuse this newer shape with the older and still explicitly documented task(name, prerequisites, action) API.

Runner-only behavior

Jake is primarily a CLI tool, but its task APIs can be embedded in another program. Importing the package and defining tasks is usable in a plain script; task discovery, task listing, prerequisite execution, and normal CLI invocation require Jake’s runner.

The CLI shape is:

jake [options ...] [env variables ...] target

When invoked as a runner, Jake searches for Jakefile, Jakefile.js, jakefile, or jakefile.js. If it does not find one, it searches parent directories up to the filesystem root and errors if none is found. It automatically loads .js files from jakelib after the main Jakefile; -J/--jakelibdir overrides that directory.

Do not put describe, it, or expect in a directly executed example: they are not provided by Jake’s package import. Likewise, do not assume that merely importing a Jakefile executes its tasks.

What this skill does not cover

• The exact signatures or behavior of the exposed classes and helpers beyond the documented task-definition surface.
• The signatures of run, parseAllTasks, attemptRule, createTask, or other internal/programmatic runner functions.
• Jake CLI options beyond the invocation shape and -J/--jakelibdir behavior described above.
• Filesystem effects and the actual execution order of runner-discovered tasks.
• A v12-specific migration guide: the supplied changelog has no v11 or v12 migration/change section.
• Undocumented behavior of rule, publishing helpers, test helpers, timeout configuration, or completion/failure signaling.