create-packkit 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DanMat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# Packkit 📦
+
+> A highly configurable scaffolder for modern **npm packages and CLIs** — pick your stack from a CLI **or** a web configurator, and get a ready-to-ship repo.
+
+[![Configure on the web](https://img.shields.io/badge/configure-on%20the%20web-00e5ff)](https://danmat.github.io/create-packkit/)
+[![npm](https://img.shields.io/npm/v/create-packkit)](https://www.npmjs.com/package/create-packkit)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Most scaffolders lock you into one stack, one language, and the terminal. Packkit lets you **choose** — TypeScript or JavaScript, library or CLI, 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
+
+```sh
+# interactive wizard
+npm create packkit@latest
+# or the short alias
+npx packkit
+
+# skip the wizard with a preset
+npx packkit ts-lib my-lib
+npx packkit cli my-tool
+npx 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.
+
+## Or configure it on the web
+
+No install needed: **[danmat.github.io/create-packkit](https://danmat.github.io/create-packkit/)** — tick the options, preview the file tree, and **download a zip** (or copy the equivalent `npx packkit` command). Everything runs in your browser.
+
+## What you can pick
+
+| Area | Options |
+|---|---|
+| **Language** | TypeScript (strict) · JavaScript (ESM) |
+| **Module format** | ESM · CJS · dual (proper `exports` map) |
+| **Target** | Library · CLI tool · both |
+| **Bundler** | tsup · tsdown · unbuild · rollup · none (tsc) |
+| **Tests** | Vitest · Jest · node:test · none (+ coverage) |
+| **Lint/format** | ESLint + Prettier · Biome · oxlint · none |
+| **Git hooks** | simple-git-hooks · husky + lint-staged · lefthook · none |
+| **Release** | Changesets · release-it · np · none |
+| **GitHub Actions** | CI · npm publish (provenance) · Pages · CodeQL · Codecov · stale bot |
+| **Deps** | Renovate · Dependabot · none |
+| **Repo** | LICENSE · community files · **AGENTS.md + CLAUDE.md** · VS Code · `.editorconfig` |
+| **Package manager** | npm · pnpm · yarn · bun |
+
+## Presets
+
+`ts-lib` · `js-lib` · `ts-cli` / `cli` · `minimal` · `full` — named bundles of the options above.
+
+## 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).
+
+Both drive from one options schema ([`src/core/options.js`](src/core/options.js)), so the CLI and the web page always stay in sync.
+
+## License
+
+[MIT](LICENSE) © DanMat

package/bin/cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { run } from '../src/cli/index.js';
+
+run().catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "create-packkit",
+  "version": "0.1.1",
+  "description": "Highly configurable scaffolder for modern npm packages and CLIs — pick your stack (TS/JS, bundler, tests, linter, CI, releases) from a CLI or a web configurator.",
+  "type": "module",
+  "bin": {
+    "create-packkit": "bin/cli.js",
+    "packkit": "bin/cli.js"
+  },
+  "exports": {
+    ".": "./src/core/index.js",
+    "./core": "./src/core/index.js",
+    "./cli": "./src/cli/index.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "start": "node bin/cli.js",
+    "test": "node --test",
+    "build:web": "esbuild src/core/index.js --bundle --format=esm --outfile=docs/packkit-core.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DanMat/create-packkit.git"
+  },
+  "keywords": [
+    "create",
+    "scaffold",
+    "scaffolding",
+    "generator",
+    "boilerplate",
+    "starter",
+    "template",
+    "npm-package",
+    "typescript",
+    "cli",
+    "tsup",
+    "vitest"
+  ],
+  "author": "DanMat <dannymatthew@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/DanMat/create-packkit/issues"
+  },
+  "homepage": "https://danmat.github.io/create-packkit/",
+  "dependencies": {
+    "@clack/prompts": "^0.7.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.23.0"
+  }
+}

package/src/cli/args.js

@@ -0,0 +1,62 @@
+import { parseArgs } from 'node:util';
+import { PRESET_NAMES } from '../core/presets.js';
+
+// Map friendly flag names to config keys for non-interactive use.
+const OVERRIDE_FLAGS = {
+  language: 'language',
+  module: 'moduleFormat',
+  bundler: 'bundler',
+  test: 'test',
+  lint: 'lint',
+  hooks: 'gitHooks',
+  release: 'release',
+  license: 'license',
+  pm: 'packageManager',
+  node: 'nodeVersion',
+  author: 'author',
+  description: 'description',
+};
+
+export function parseCliArgs(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      preset: { type: 'string' },
+      name: { type: 'string' },
+      yes: { type: 'boolean', short: 'y' },
+      here: { type: 'boolean' },
+      'no-install': { type: 'boolean' },
+      'no-git': { type: 'boolean' },
+      target: { type: 'string', multiple: true },
+      help: { type: 'boolean', short: 'h' },
+      version: { type: 'boolean', short: 'v' },
+      ...Object.fromEntries(Object.keys(OVERRIDE_FLAGS).map((k) => [k, { type: 'string' }])),
+    },
+  });
+
+  // First positional may be a known preset; otherwise it's the project name.
+  let preset = values.preset;
+  const pos = [...positionals];
+  if (!preset && pos.length && PRESET_NAMES.includes(pos[0])) preset = pos.shift();
+  const name = values.name || pos[0];
+
+  const overrides = {};
+  for (const [flag, key] of Object.entries(OVERRIDE_FLAGS)) {
+    if (values[flag] != null) overrides[key] = values[flag];
+  }
+  if (values.target) overrides.target = values.target;
+  if (name) overrides.name = name;
+
+  return {
+    preset,
+    name,
+    here: !!values.here,
+    yes: !!values.yes,
+    install: !values['no-install'],
+    git: !values['no-git'],
+    help: !!values.help,
+    version: !!values.version,
+    overrides,
+  };
+}

package/src/cli/index.js

@@ -0,0 +1,112 @@
+import { resolve, basename } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import * as p from '@clack/prompts';
+import { generate, fromPreset, normalizeConfig, PRESET_NAMES } from '../core/index.js';
+import { parseCliArgs } from './args.js';
+import { runWizard } from './wizard.js';
+import { writeProject, dirIsEmptyOrMissing, gitInit, installDeps } from './write.js';
+
+const pkgVersion = () => {
+  try {
+    const url = new URL('../../package.json', import.meta.url);
+    return JSON.parse(readFileSync(fileURLToPath(url), 'utf8')).version;
+  } catch {
+    return '0.0.0';
+  }
+};
+
+const HELP = `
+packkit — scaffold a modern npm package or CLI
+
+Usage:
+  npm create packkit@latest [name] [options]
+  npx packkit [preset] [name] [options]
+
+Presets: ${PRESET_NAMES.join(', ')}
+
+Options:
+  --preset <name>     Use a preset (skips the wizard)
+  --name <name>       Package name
+  --here              Scaffold into the current directory
+  -y, --yes           Accept defaults / preset, no prompts
+  --no-install        Skip dependency install
+  --no-git            Skip git init
+  --pm <manager>      npm | pnpm | yarn | bun
+  --language <ts|js>  --module <esm|cjs|dual>  --bundler <tsup|tsdown|unbuild|rollup|none>
+  --test <vitest|jest|node|none>  --lint <eslint-prettier|biome|oxlint|none>
+  --license <MIT|Apache-2.0|ISC|none>
+  -h, --help          Show this help
+  -v, --version       Show version
+
+Examples:
+  npx packkit ts-lib my-lib
+  npm create packkit@latest my-cli -- --preset cli
+  npx packkit --preset full my-pkg --pm pnpm
+`;
+
+export async function run(argv = process.argv.slice(2)) {
+  const args = parseCliArgs(argv);
+  if (args.help) return void console.log(HELP);
+  if (args.version) return void console.log(pkgVersion());
+
+  const interactive = !args.preset && !args.yes && process.stdout.isTTY;
+
+  let config;
+  if (interactive) {
+    p.intro('📦 Packkit');
+    config = normalizeConfig(await runWizard(args.overrides));
+  } else if (args.preset) {
+    config = fromPreset(args.preset, args.overrides);
+  } else {
+    config = normalizeConfig(args.overrides);
+  }
+
+  config.gitInit = args.git;
+  config.install = args.install;
+
+  // Resolve the target directory.
+  const targetDir = args.here ? process.cwd() : resolve(process.cwd(), config.name);
+  if (!args.here && !config.name) {
+    console.error('A package name is required (pass one, or run interactively).');
+    process.exit(1);
+  }
+  if (!dirIsEmptyOrMissing(targetDir)) {
+    console.error(`Target directory "${basename(targetDir)}" is not empty. Aborting.`);
+    process.exit(1);
+  }
+
+  // Generate + write.
+  const { files, summary } = generate(config);
+  await writeProject(targetDir, files);
+
+  // Post steps.
+  if (config.gitInit) gitInit(targetDir);
+  if (config.install) {
+    const s = p.spinner();
+    s.start(`Installing dependencies with ${config.packageManager}`);
+    const ok = installDeps(config.packageManager, targetDir);
+    s.stop(ok ? 'Dependencies installed' : 'Install skipped (run it manually)');
+  }
+
+  const rel = args.here ? '.' : config.name;
+  const next = [
+    args.here ? null : `cd ${rel}`,
+    config.install ? null : `${config.packageManager} install`,
+    summary.stack.includes('tsup') || summary.stack.includes('tsdown') ? `${runWord(config)} build` : null,
+    summary.stack.some((s) => ['vitest', 'jest'].includes(s)) ? `${runWord(config)} test` : null,
+  ].filter(Boolean);
+
+  const done = `Created ${summary.name} — ${summary.fileCount} files · ${summary.stack.join(' · ')}`;
+  if (interactive) {
+    p.note(next.join('\n') || 'You are all set.', 'Next steps');
+    p.outro(done);
+  } else {
+    console.log(done);
+    if (next.length) console.log('\nNext steps:\n  ' + next.join('\n  '));
+  }
+}
+
+function runWord(config) {
+  return config.packageManager === 'npm' ? 'npm run' : config.packageManager;
+}

package/src/cli/wizard.js

@@ -0,0 +1,59 @@
+import * as p from '@clack/prompts';
+import { OPTIONS } from '../core/options.js';
+
+function bail(value) {
+  if (p.isCancel(value)) {
+    p.cancel('Cancelled.');
+    process.exit(0);
+  }
+  return value;
+}
+
+const asOptions = (key) => OPTIONS[key].choices.map((c) => ({ value: c.value, label: c.label }));
+
+/** Run the interactive wizard, returning a partial config. `seed` pre-fills. */
+export async function runWizard(seed = {}) {
+  const cfg = { ...seed };
+
+  cfg.name = bail(
+    await p.text({
+      message: 'Package name',
+      placeholder: 'my-package',
+      initialValue: seed.name || '',
+      validate: (v) => (!v ? 'Required' : /^(@[\w.-]+\/)?[\w.-]+$/.test(v) ? undefined : 'Invalid npm name'),
+    }),
+  );
+
+  cfg.description = bail(await p.text({ message: 'Description', placeholder: '(optional)', defaultValue: '' }));
+  cfg.author = bail(await p.text({ message: 'Author', placeholder: '(optional)', defaultValue: seed.author || '' }));
+
+  cfg.language = bail(await p.select({ message: 'Language', options: asOptions('language'), initialValue: OPTIONS.language.default }));
+  cfg.target = bail(await p.multiselect({ message: 'What are you building?', options: asOptions('target'), initialValues: ['library'], required: true }));
+  cfg.moduleFormat = bail(await p.select({ message: 'Module format', options: asOptions('moduleFormat'), initialValue: OPTIONS.moduleFormat.default }));
+  cfg.packageManager = bail(await p.select({ message: 'Package manager', options: asOptions('packageManager'), initialValue: OPTIONS.packageManager.default }));
+  cfg.bundler = bail(await p.select({ message: 'Build / bundler', options: asOptions('bundler'), initialValue: OPTIONS.bundler.default }));
+  cfg.test = bail(await p.select({ message: 'Test runner', options: asOptions('test'), initialValue: OPTIONS.test.default }));
+  cfg.lint = bail(await p.select({ message: 'Lint / format', options: asOptions('lint'), initialValue: OPTIONS.lint.default }));
+  cfg.gitHooks = bail(await p.select({ message: 'Git hooks', options: asOptions('gitHooks'), initialValue: OPTIONS.gitHooks.default }));
+  cfg.release = bail(await p.select({ message: 'Release / versioning', options: asOptions('release'), initialValue: OPTIONS.release.default }));
+  cfg.workflows = bail(await p.multiselect({ message: 'GitHub Actions (space to toggle)', options: asOptions('workflows'), initialValues: OPTIONS.workflows.default, required: false }));
+  cfg.deps = bail(await p.select({ message: 'Dependency updates', options: asOptions('deps'), initialValue: OPTIONS.deps.default }));
+  cfg.license = bail(await p.select({ message: 'License', options: asOptions('license'), initialValue: OPTIONS.license.default }));
+
+  const extras = bail(
+    await p.multiselect({
+      message: 'Extras (space to toggle)',
+      options: [
+        { value: 'community', label: 'Community files (CONTRIBUTING, CoC, SECURITY, templates)' },
+        { value: 'agents', label: 'AI agent instructions (AGENTS.md + CLAUDE.md)' },
+        { value: 'vscode', label: 'VS Code settings' },
+        { value: 'editorconfig', label: '.editorconfig' },
+      ],
+      initialValues: ['community', 'agents', 'vscode', 'editorconfig'],
+      required: false,
+    }),
+  );
+  for (const key of ['community', 'agents', 'vscode', 'editorconfig']) cfg[key] = extras.includes(key);
+
+  return cfg;
+}

package/src/cli/write.js

@@ -0,0 +1,46 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { existsSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+/** Write a { path: contents } map under `targetDir`. Returns the count. */
+export async function writeProject(targetDir, files) {
+  for (const [rel, contents] of Object.entries(files)) {
+    const full = join(targetDir, rel);
+    await mkdir(dirname(full), { recursive: true });
+    await writeFile(full, contents);
+  }
+  return Object.keys(files).length;
+}
+
+/** True if the directory doesn't exist or contains no entries. */
+export function dirIsEmptyOrMissing(dir) {
+  if (!existsSync(dir)) return true;
+  try {
+    return readdirSync(dir).length === 0;
+  } catch {
+    return false;
+  }
+}
+
+/** Run a command in `cwd` (arg array — no shell parsing). Never throws. */
+export function run(cmd, args, cwd, { quiet = true } = {}) {
+  const res = spawnSync(cmd, args, {
+    cwd,
+    stdio: quiet ? 'ignore' : 'inherit',
+    shell: process.platform === 'win32',
+  });
+  return res.status === 0;
+}
+
+/** git init + initial commit. Returns true on success. */
+export function gitInit(cwd) {
+  if (!run('git', ['init', '--quiet'], cwd)) return false;
+  run('git', ['add', '-A'], cwd);
+  return run('git', ['commit', '-m', 'Initial commit from Packkit', '--quiet'], cwd);
+}
+
+/** Install dependencies with the chosen package manager. */
+export function installDeps(pm, cwd) {
+  return run(pm, ['install'], cwd, { quiet: false });
+}

package/src/core/features/agents.js

@@ -0,0 +1,57 @@
+// AGENTS.md (the emerging cross-tool standard) + CLAUDE.md pointer. Describes
+// the stack and the exact commands so coding agents work correctly out of the box.
+
+export default {
+  id: 'agents',
+  active: (cfg) => cfg.agents,
+  apply(cfg) {
+    const run = (s) => (cfg.packageManager === 'npm' ? `npm run ${s}` : `${cfg.packageManager} ${s}`);
+    const test = cfg.packageManager === 'npm' ? 'npm test' : `${cfg.packageManager} test`;
+
+    const commands = [];
+    if (cfg.isTs) commands.push(`- Type-check: \`${run('typecheck')}\``);
+    if (cfg.lint !== 'none') commands.push(`- Lint: \`${run('lint')}\``);
+    if (cfg.test !== 'none') commands.push(`- Test: \`${test}\``);
+    if (cfg.bundler !== 'none' || cfg.isTs) commands.push(`- Build: \`${run('build')}\``);
+
+    const stack = [
+      `- Language: ${cfg.isTs ? 'TypeScript (strict)' : 'JavaScript (ESM)'}`,
+      `- Module format: ${cfg.moduleFormat.toUpperCase()}`,
+      `- Package manager: ${cfg.packageManager}`,
+      cfg.bundler !== 'none' ? `- Bundler: ${cfg.bundler}` : `- Build: ${cfg.isTs ? 'tsc' : 'none'}`,
+      cfg.test !== 'none' ? `- Tests: ${cfg.test}` : null,
+      cfg.lint !== 'none' ? `- Lint/format: ${cfg.lint}` : null,
+    ].filter(Boolean);
+
+    const agents = [
+      `# AGENTS.md`,
+      ``,
+      `Guidance for AI coding agents working in **${cfg.name}**.`,
+      ``,
+      `## Stack`,
+      ``,
+      ...stack,
+      ``,
+      `## Commands`,
+      ``,
+      ...commands,
+      ``,
+      `## Conventions`,
+      ``,
+      `- Source lives in \`src/\`. Keep the public API in \`src/index.${cfg.ext}\`.`,
+      `- Add or update tests for any behavior change.`,
+      cfg.isTs ? `- Prefer explicit types on exported functions; keep \`strict\` passing.` : `- Use ESM syntax and JSDoc types where helpful.`,
+      cfg.release === 'changesets' ? `- Run \`npx changeset\` after a user-facing change.` : null,
+      `- Do not commit \`dist/\` or \`node_modules/\`.`,
+      ``,
+    ].filter((l) => l !== null).join('\n');
+
+    return {
+      files: {
+        'AGENTS.md': agents,
+        'CLAUDE.md': `See [AGENTS.md](./AGENTS.md) for build/test commands and conventions.\n`,
+      },
+      pkg: {},
+    };
+  },
+};

package/src/core/features/bundler.js

@@ -0,0 +1,118 @@
+// Always-on. Owns the package entry points (exports/main/module/types/files)
+// and the build tooling for the chosen bundler.
+
+export default {
+  id: 'bundler',
+  active: () => true,
+  apply(cfg) {
+    const files = {};
+    const pkg = { scripts: {} };
+    const build = cfg.bundler !== 'none';
+
+    // ---- entry points ----
+    if (!build && !cfg.isTs) {
+      // Plain JS, no build: ship source directly.
+      pkg.files = ['src'];
+      pkg.exports = { '.': `./src/index.js` };
+      pkg.main = './src/index.js';
+      if (cfg.hasEsm) pkg.module = './src/index.js';
+    } else {
+      pkg.files = ['dist'];
+      const esm = './dist/index.js';
+      const cjs = './dist/index.cjs';
+      const dts = './dist/index.d.ts';
+      const exp = {};
+      if (cfg.isTs) exp.types = dts;
+      if (cfg.hasEsm) exp.import = esm;
+      if (cfg.hasCjs) exp.require = build ? cjs : './dist/index.cjs';
+      pkg.exports = { '.': exp };
+      if (cfg.hasCjs) pkg.main = exp.require;
+      else pkg.main = esm;
+      if (cfg.hasEsm) pkg.module = esm;
+      if (cfg.isTs) pkg.types = dts;
+    }
+
+    // ---- build tooling ----
+    const entries = ['src/index.' + cfg.ext];
+    if (cfg.hasCli) entries.push('src/cli.' + cfg.ext);
+    const formats = [cfg.hasEsm && 'esm', cfg.hasCjs && 'cjs'].filter(Boolean);
+
+    if (cfg.bundler === 'tsup' || cfg.bundler === 'tsdown') {
+      const tool = cfg.bundler;
+      files[`${tool}.config.${cfg.ext}`] = tsupConfig(cfg, entries, formats, tool);
+      pkg.scripts.build = tool;
+      pkg.scripts.dev = `${tool} --watch`;
+      pkg.devDependencies = { [tool]: tool === 'tsup' ? '^8.0.0' : '^0.6.0' };
+    } else if (cfg.bundler === 'unbuild') {
+      files['build.config.ts'] = unbuildConfig(cfg);
+      pkg.scripts.build = 'unbuild';
+      pkg.scripts.dev = 'unbuild --stub';
+      pkg.devDependencies = { unbuild: '^2.0.0' };
+    } else if (cfg.bundler === 'rollup') {
+      files[`rollup.config.${cfg.ext === 'ts' ? 'ts' : 'js'}`] = rollupConfig(cfg, formats);
+      pkg.scripts.build = 'rollup -c';
+      pkg.scripts.dev = 'rollup -c -w';
+      pkg.devDependencies = {
+        rollup: '^4.0.0',
+        ...(cfg.isTs ? { '@rollup/plugin-typescript': '^11.0.0', tslib: '^2.6.0' } : {}),
+      };
+    } else if (cfg.bundler === 'none' && cfg.isTs) {
+      // tsc-only build for TypeScript.
+      pkg.scripts.build = 'tsc';
+      pkg.scripts.dev = 'tsc --watch';
+    }
+
+    if (build) pkg.scripts.prepublishOnly = pkg.scripts.build;
+    pkg.scripts.clean = 'rimraf dist';
+    if (build) pkg.devDependencies = { ...pkg.devDependencies, rimraf: '^6.0.0' };
+
+    return { files, pkg };
+  },
+};
+
+function tsupConfig(cfg, entries, formats, tool) {
+  return [
+    `import { defineConfig } from '${tool}';`,
+    ``,
+    `export default defineConfig({`,
+    `\tentry: [${entries.map((e) => `'${e}'`).join(', ')}],`,
+    `\tformat: [${formats.map((f) => `'${f}'`).join(', ')}],`,
+    cfg.isTs ? `\tdts: true,` : null,
+    `\tsourcemap: true,`,
+    `\tclean: true,`,
+    `\ttreeshake: true,`,
+    `});`,
+    ``,
+  ].filter((l) => l !== null).join('\n');
+}
+
+function unbuildConfig(cfg) {
+  return [
+    `import { defineBuildConfig } from 'unbuild';`,
+    ``,
+    `export default defineBuildConfig({`,
+    `\tentries: ['src/index'],`,
+    `\tdeclaration: ${cfg.isTs},`,
+    `\tclean: true,`,
+    `\trollup: { emitCJS: ${cfg.hasCjs} },`,
+    `});`,
+    ``,
+  ].join('\n');
+}
+
+function rollupConfig(cfg, formats) {
+  const out = formats
+    .map((f) => `\t\t{ file: 'dist/index.${f === 'cjs' ? 'cjs' : 'js'}', format: '${f}', sourcemap: true }`)
+    .join(',\n');
+  const tsPlugin = cfg.isTs ? `\n\tplugins: [typescript()],` : '';
+  const tsImport = cfg.isTs ? `import typescript from '@rollup/plugin-typescript';\n` : '';
+  return [
+    tsImport + `export default {`,
+    `\tinput: 'src/index.${cfg.ext}',`,
+    `\toutput: [`,
+    out,
+    `\t],${tsPlugin}`,
+    `};`,
+    ``,
+  ].join('\n');
+}

package/src/core/features/cli.js

@@ -0,0 +1,35 @@
+// CLI target: a `bin` entry + a minimal command scaffold with a shebang.
+
+export default {
+  id: 'cli',
+  active: (cfg) => cfg.hasCli,
+  apply(cfg) {
+    const build = cfg.bundler !== 'none';
+    const binPath = build || cfg.isTs ? './dist/cli.js' : './src/cli.js';
+    const files = {};
+
+    files[`src/cli.${cfg.ext}`] = cliScaffold(cfg);
+
+    return {
+      files,
+      pkg: {
+        bin: { [binName(cfg.name)]: binPath },
+      },
+    };
+  },
+};
+
+function binName(name) {
+  // scoped packages -> use the part after the slash as the command
+  return name.startsWith('@') ? name.split('/')[1] : name;
+}
+
+function cliScaffold(cfg) {
+  const importLine = cfg.hasLibrary
+    ? `import { greet } from './index.${cfg.isTs ? 'js' : 'js'}';\n`
+    : '';
+  const body = cfg.hasLibrary
+    ? `const name = process.argv[2] ?? 'world';\nconsole.log(greet(name));\n`
+    : `console.log('${cfg.name} — hello from your CLI');\n`;
+  return `#!/usr/bin/env node\n${importLine}\n${body}`;
+}