Stacks

Scaffold a template and its addons in one shot

A stack is a template plus an ordered list of addons, declared in an anesis.stack.json manifest. Run anesis new my-app --stack <id> and Anesis scaffolds the template, then applies every addon in order — the same pipeline as running each step by hand, wired together.

anesis new <dir> --stack <id>Ordered addon applicationPreset addon inputs

Browse stacks Open the builder Creating stacks

Scaffolding from a stack

This is the primary way to use a stack — one command instead of a template plus a series of anesis use calls.

# Scaffold a project directly from a stack (auto-installs if uncached)
anesis new my-app --stack nest-saas

# Or install first, then scaffold
anesis stack install nest-saas
anesis new my-app --stack nest-saas

The anesis.stack.json manifest

A stack manifest names a template and lists the addons to apply on top of it, in order.

{
  "schema_version": "1",
  "id": "nest-saas",
  "name": "NestJS SaaS Starter",
  "description": "NestJS backend with Prisma, JWT auth, Swagger docs and request validation.",
  "version": "1.0.0",
  "author": { "name": "Maksym Zhuk", "github": "anesis-dev" },
  "template": "nest-express",
  "addons": [
    { "id": "nest-prisma-v7", "command": "install" },
    { "id": "nest-auth-jwt", "command": "install" },
    { "id": "nest-swagger", "command": "install" },
    { "id": "nest-validation", "command": "install" }
  ]
}

Key fields

version: Semver version of the stack. Publishing a new version adds an entry; the registry lists the latest with a version count, and re-publishing an existing version is rejected.
author: Object with name and github — the GitHub handle links the stack to its author and shows on every stack card.
template: The template name to scaffold first — the same value you'd pass to anesis new <name> <template>.
addons[].id: Addon id to apply, in order, after the template is scaffolded.
addons[].command: Command to run on that addon. Defaults to "install" if omitted.
addons[].inputs: Preset input values for this addon, so the user isn't re-prompted for anything the stack already decided. Missing inputs are still prompted unless --yes is passed.

What happens when a stack runs

A stack doesn't introduce a new execution model — it drives the exact same template and addon pipelines documented elsewhere, in sequence.

The template is scaffolded first, exactly as anesis new would do it (including its own inputs/exclude handling).
Each addon in addons then runs in the order listed, via the same anesis use <id> <command> pipeline — variant detection, input prompts, and step execution all apply.
Any preset in addons[].inputs is used as a default; you're only prompted for values the stack didn't pin (unless --yes is set, which accepts every default).
If an addon fails, the stack aborts with an error naming which addon failed. Steps already applied by that addon are rolled back the same way a standalone anesis use failure would be; earlier addons in the stack are not undone automatically.

Installing and inspecting stacks

Stacks have their own local cache, separate from templates and addons.

Stacks are cached at ~/.anesis/cache/stacks/<id>.json — a single manifest file per stack, unlike templates/addons which cache whole directories.
anesis stack install <id> pre-downloads and caches a stack manifest. Optional — anesis new --stack <id> auto-installs it when missing.
anesis stack list and anesis stack remove operate on the local cache only, no login required.
anesis stack info <id> prints the template and ordered addon list; it prefers the freshest registry copy but falls back to the local cache if the registry is unreachable.

Publishing a stack

Stacks are published from a GitHub URL the same way templates and addons are.

anesis stack publish https://github.com/owner/repo
anesis stack republish https://github.com/owner/repo

Both accept --visibility, --credential-id, and --org-id — see the command reference for the full flag list. A saved login (anesis login) is required.

Next steps

A stack only references templates and addons that already exist in the registry.

Creating Templates — build the base project the stack scaffolds first.
Creating Addons — build the addons the stack applies on top, in order.
Once both exist in the registry, see Creating Stacks for how to plan the composition and generate the manifest — the builder can also add extra one-off terminal commands (like bun add tailwindcss) alongside your addons before you write anesis stack publish.

Publishing Addons

Creating Stacks

Loading…