Packkit

Packkit 📦

A highly configurable generator for modern JS/TS projects — packages, CLIs, apps, services, and full-stack repos — from a CLI or a web configurator, with a stable embedded API and safe upgrades.

Most scaffolders lock you into one stack, one language, and the terminal. Packkit lets you choose — TypeScript or JavaScript, library, CLI, app, service, or full-stack monorepo, ESM/CJS/dual, your bundler, test runner, linter, git hooks, release flow, GitHub Actions and more — and it works from a CLI or a browser page that downloads your project as a zip.

Quick start

# interactive wizard
npm create packkit@latest
# or with npx
npx create-packkit

# skip the wizard with a preset
npx create-packkit ts-lib my-lib
npx create-packkit cli my-tool
npx create-packkit --preset full my-pkg --pm pnpm

Then cd, and you already have a working project — build, test, and lint all pass out of the box.

Create the repo, not just the folder

Packkit can create the remote and push the first commit, so you don't have to make an empty repo in a browser first:

# create it on GitHub (private) and push
npx create-packkit ts-lib my-lib --github

# public instead
npx create-packkit ts-lib my-lib --github --public

# any other host — GitLab, Bitbucket, Gitea, self-hosted
npx create-packkit ts-lib my-lib --git-remote [email protected]:me/my-lib.git

--github shells out to the GitHub CLI, so Packkit never asks for, reads, or stores a token — gh already holds your credentials. Created repos are private unless you pass --public.

This also fixes your links: the repository URL is baked into package.json and the README's CI badges when the files are generated, so letting Packkit resolve it up front means the badges point somewhere real from the first commit.

Scaffolding into a repo you already have

Already cloned an empty repo, or started some work? --merge scaffolds around what's there:

git clone [email protected]:me/my-lib.git && cd my-lib
npx create-packkit ts-lib my-lib --here --merge

Existing files are never overwritten. Anything that collides is left alone and reported, so you can diff at your leisure. (A directory containing only .git counts as empty — a fresh clone scaffolds without needing --merge at all.)

Keep a project current

Every scaffolded project records what it came from in packkit.json. Later, from inside the project:

npx create-packkit upgrade          # dry run: what's changed since you scaffolded
npx create-packkit upgrade --apply  # bring in the additive changes, keep your edits

Upgrade regenerates the project Packkit would produce today and diffs it against disk. --apply is non-destructive: it brings in additions and preserves anything that already exists but differs — because without a stored baseline it can't tell a template change from your own edit. Replacing differing values is opt-in, per category:

Your own files, scripts, and dependencies are never touched by --apply. The report lists everything preserved so you can review it and opt into replacement where you want Packkit's version.

Baseline-aware (new projects). Projects scaffolded with Packkit 3.3+ record a baseline of what was generated (in packkit.json), so upgrade can do a three-way comparison and tell the difference between a change you made and one the template made:

• template-only change (you didn't edit it) → applied by --apply, safely;
• your edit (the template didn't change) → preserved;
• both changed → flagged as a conflict to review.

Older projects without a baseline fall back to the conservative rule: anything that differs is preserved for review.

Either way, --apply never overwrites your own edits or resolves conflicts for you — those are always preserved. --json reports the classification and baselineAvailable for automation.

Honest provenance. After an upgrade, packkit.json records what actually happened rather than claiming the project is a fresh scaffold of the new version. version (the version you generated with) is left untouched; lastUpgradeAppliedWith records the version applied, and upgradeStatus is current only when nothing was left behind — a partial upgrade that preserved your edits is marked partial with an unresolvedChanges count.

Or configure it on the web

No install needed: packkit-web.pages.dev — pick a language (JS/TS or Python), tick the options, preview the file tree, and download a zip (or copy the equivalent command). Everything runs in your browser.

Options reference

Every flag, its values (default in bold), and what it's for. Prefer the interactive web configurator — the same descriptions appear as you hover. This table is generated from the schema (npm run gen:reference).

Package

Core

Build

Quality

Release

CI / CD

Repository

Presets

Named bundles of the options above — npx packkit <preset> <name> -y.

Team profiles: save a partial config as packkit.config.json (or any file) and reuse it with npx create-packkit my-lib --from ./packkit.config.json — flags still override the file.

For AI agents & automation

Packkit is safe to drive non-interactively — every option is a flag, so no prompts are needed. Agents can introspect the whole interface as JSON:

npx create-packkit --schema      # all options, presets, and aliases as JSON
npx create-packkit my-lib ts-lib --no-install --no-git   # deterministic scaffold

There's also an llms.txt (served at packkitlabs.github.io/create-packkit-js/llms.txt) describing the commands for LLMs.

MCP server — packkit-mcp exposes every Packkit generator (JS/TS + Python) as native Model Context Protocol tools. Add to your agent's MCP config:

{ "mcpServers": { "packkit": { "command": "npx", "args": ["-y", "packkit-mcp"] } } }

Embed Packkit in your own app

Packkit ships a typed, side-effect-free API so a Node application can use it as a project-generation engine — generate in memory, add your own deployment files, and write to disk when you're ready. No prompts, installs, git, or network.

import { createProject, extendProject, writeGeneratedProject } from 'create-packkit/embedded';

const project = createProject({ preset: 'react-app', name: 'weather-dashboard' });
const extended = extendProject(project, { files: { '.github/workflows/deploy.yml': deployYaml } });
await writeGeneratedProject({ project: extended, destination: '/tmp/weather-dashboard' });

Full guide, including diagnostics, reproducible definitions, digests, and the provider-neutral deployment contract: Embedding Packkit.

How it works

Packkit is a pure config → { files } core that runs in both Node and the browser:

• the CLI writes the files to disk, runs git init, and installs dependencies;
• the web configurator zips the same files client-side (no server);
• the embedded API (create-packkit/embedded) hands the file map to a host application.

All three drive from one options schema (src/core/options.js), so they always stay in sync.

Staying fresh

Two GitHub Actions keep the templates honest:

• Dependency freshness — a weekly check flags any version Packkit writes into generated projects that's fallen a major behind (versions Dependabot can't see), and opens an issue.
• Integration — on any change to generation logic or a template dependency, it generates every preset, installs it, and runs its real checks (build/test/lint, and actually starts services) — so an update can't silently break the projects you'd get.

License

MIT © DanMat