`,
+ `\t\t\t${cfg.name}
`,
+ `\t\t\t{health ? describeHealth(health) : 'Checking…'}
`,
+ `\t\t`,
+ `\t);`,
+ `}`,
+ ``,
+ ].join('\n');
+
+ return {
+ config: cfg,
+ files,
+ postCommands: cfg.gitInit ? ['git init', 'git add -A', 'git commit -m "Initial commit from Packkit"'] : [],
+ summary: {
+ name: cfg.name,
+ fileCount: Object.keys(files).length,
+ stack: ['monorepo', 'full-stack', `${pm}+turbo`, 'React+Vite', 'Hono', 'TypeScript', 'vitest'],
+ workflows: ['ci'],
+ },
+ };
+}
+
+function fullstackReadme(cfg, pm, shared) {
+ const install = pm === 'npm' ? 'npm install' : `${pm} install`;
+ const run = (s) => (pm === 'npm' ? `npm run ${s}` : `${pm} ${s}`);
+ return [
+ `# ${cfg.name}`,
+ '',
+ cfg.description || '_A full-stack monorepo scaffolded with [Packkit](https://danmat.github.io/create-packkit/)._',
+ '',
+ '## Layout',
+ '',
+ '```',
+ 'apps/web React + Vite front end',
+ 'apps/server Hono API (also serves the web build in production)',
+ 'packages/shared types and helpers both sides import',
+ '```',
+ '',
+ '## Develop',
+ '',
+ '```sh',
+ install,
+ run('dev') + ' # web on :5173, api on :3000',
+ '```',
+ '',
+ `Vite proxies \`/api\` to the server, so requests are same-origin in development exactly as they are in production — no CORS, no environment-specific base URL.`,
+ '',
+ '## Production',
+ '',
+ '```sh',
+ run('build'),
+ run('start') + ' # one process serving the API and the built web app',
+ '```',
+ '',
+ `\`${shared}\` is built before either app starts, so a change to a shared type surfaces as a type error on both sides rather than at runtime.`,
+ '',
+ cfg.license !== 'none' ? `## License\n\n${cfg.license}${cfg.author ? ' © ' + cfg.author : ''}\n` : '',
+ ].join('\n');
+}
+
function addPackage(files, { name, dir, src, test, deps }) {
const pkg = {
name,
diff --git a/src/core/options.js b/src/core/options.js
index abb6640..eaacdf2 100644
--- a/src/core/options.js
+++ b/src/core/options.js
@@ -54,6 +54,14 @@ export const OPTIONS = {
monorepo: {
group: 'core', type: 'boolean', label: 'Monorepo (pnpm/Turborepo workspace)', default: false,
},
+ monorepoLayout: {
+ group: 'core', type: 'select', label: 'Monorepo layout', default: 'libraries',
+ when: (cfg) => cfg.monorepo,
+ choices: [
+ { value: 'libraries', label: 'Libraries — linked packages you publish' },
+ { value: 'fullstack', label: 'Full-stack app — web + server + shared' },
+ ],
+ },
framework: {
group: 'core', type: 'select', label: 'Framework', default: 'none',
choices: [
@@ -209,6 +217,7 @@ export const OPTION_HELP = {
moduleFormat: 'How the package is consumed. ESM-only (default) is the modern, leanest choice — Node 20.19+/22.12+ can `require()` ESM. Pick dual only if you must support older CJS-only consumers; cjs-only is rarely needed.',
target: 'What you are building — mix and match: a library (importable package), a CLI (ships a bin), an HTTP service, or an app (Vite SPA).',
serviceFramework: 'For the service target: Hono (fast, web-standard, tiny — default), Fastify (batteries-included, plugins, schema validation), or Express (ubiquitous, huge ecosystem).',
+ monorepoLayout: 'What the workspace contains. "libraries" gives linked packages you publish (Changesets). "fullstack" gives apps/web (React+Vite) + apps/server (Hono) + packages/shared, wired together, with the server serving the web build in production.',
monorepo: 'Generate a pnpm + Turborepo workspace with two linked example packages and Changesets. Only worth it when ≥2 packages share code.',
framework: 'UI framework for component libraries and apps: React, Vue, or Svelte (or none for a plain package).',
packageManager: 'Which package manager the scripts, lockfile, and CI target: npm, pnpm, yarn, or bun.',
diff --git a/src/core/presets.js b/src/core/presets.js
index d8d02c0..5a7eea8 100644
--- a/src/core/presets.js
+++ b/src/core/presets.js
@@ -19,6 +19,10 @@ export const PRESETS = {
release: 'none', workflows: ['ci'], deps: 'renovate', agents: true, vscode: true,
},
monorepo: { monorepo: true, language: 'ts', packageManager: 'pnpm' },
+ fullstack: {
+ monorepo: true, monorepoLayout: 'fullstack', language: 'ts', packageManager: 'pnpm',
+ framework: 'react', test: 'vitest', release: 'none', workflows: ['ci'],
+ },
oss: {
language: 'ts', target: ['library'], moduleFormat: 'esm', bundler: 'tsup',
test: 'vitest', coverage: true, lint: 'eslint-prettier', gitHooks: 'simple-git-hooks',
@@ -53,6 +57,8 @@ export const PRESET_ALIASES = {
slib: 'svelte-lib',
sapp: 'svelte-app',
svc: 'node-service',
+ fs: 'fullstack',
+ app: 'fullstack',
service: 'node-service',
};
@@ -78,6 +84,7 @@ export const PRESET_INFO = {
'svelte-app': 'Svelte SPA — Vite dev server, build, Testing Library.',
'node-service': 'Node HTTP service (Hono) — tsx dev, tsup build, Dockerfile.',
monorepo: 'pnpm + Turborepo workspace — two example packages, Changesets, CI.',
+ fullstack: 'Full-stack monorepo — React+Vite web, Hono API, shared package; server serves the web build in production.',
oss: 'Full open-source library — coverage, CodeQL, Codecov, Renovate, Changesets.',
minimal: 'Bare TS library — tsup only, no tests/lint/CI.',
full: 'Everything on — library + CLI, all workflows and extras.',
diff --git a/src/core/provenance.js b/src/core/provenance.js
new file mode 100644
index 0000000..9f8899d
--- /dev/null
+++ b/src/core/provenance.js
@@ -0,0 +1,35 @@
+// packkit.json — what this project was generated from.
+//
+// Packkit used to leave no trace, so a project couldn't answer "what did I
+// start from?", couldn't be diffed against a newer template, and had no upgrade
+// path. This records the answer next to the code.
+//
+// Only settings that differ from the defaults are stored, so the file reads as
+// the decisions someone actually made rather than a dump of every option. It is
+// deliberately free of timestamps and machine details: generation stays a pure
+// function of the config, so the same config always produces the same bytes.
+
+import { toJson } from './render.js';
+import { defaultConfig } from './options.js';
+
+// How this particular run was invoked, rather than what the project is.
+// Replaying a config shouldn't re-run someone else's `git init` or install.
+const TRANSIENT = new Set(['gitInit', 'install', 'generatorVersion', 'preset', 'name']);
+
+export function provenance(cfg) {
+ const defaults = defaultConfig();
+ const settings = {};
+ for (const [key, value] of Object.entries(cfg)) {
+ // Skip derived helpers (isTs, hasApp, ext…) — they aren't inputs.
+ if (!(key in defaults) || TRANSIENT.has(key)) continue;
+ if (JSON.stringify(value) !== JSON.stringify(defaults[key])) settings[key] = value;
+ }
+
+ return toJson({
+ $schema: 'https://danmat.github.io/create-packkit/packkit.schema.json',
+ generator: 'create-packkit',
+ ...(cfg.generatorVersion ? { version: cfg.generatorVersion } : {}),
+ ...(cfg.preset ? { preset: cfg.preset } : {}),
+ settings,
+ });
+}
diff --git a/test/core.test.js b/test/core.test.js
index 840f97d..5b4c65b 100644
--- a/test/core.test.js
+++ b/test/core.test.js
@@ -309,3 +309,65 @@ test('every generated package.json parses', () => {
assert.doesNotThrow(() => JSON.parse(out.files['package.json']), preset);
}
});
+
+test('fullstack: web + server + shared, wired as a workspace', () => {
+ const out = generate(fromPreset('fullstack', { name: 'acme' }));
+ const root = JSON.parse(out.files['package.json']);
+ const web = JSON.parse(out.files['apps/web/package.json']);
+ const server = JSON.parse(out.files['apps/server/package.json']);
+ const shared = JSON.parse(out.files['packages/shared/package.json']);
+
+ assert.equal(out.files['pnpm-workspace.yaml'], 'packages:\n - "apps/*"\n - "packages/*"\n');
+ assert.equal(root.private, true, 'an app monorepo publishes nothing');
+
+ // Both sides depend on shared, which is what makes this a composition rather
+ // than three projects in one folder.
+ assert.ok(web.dependencies['@acme/shared']);
+ assert.ok(server.dependencies['@acme/shared']);
+ assert.equal(shared.private, true);
+
+ // The React types are what `turbo typecheck` fails without.
+ assert.ok(web.devDependencies['@types/react'], '@types/react');
+ assert.ok(web.devDependencies['@types/react-dom'], '@types/react-dom');
+ // A test script with no test files makes vitest exit 1.
+ assert.ok(out.files['apps/web/src/App.test.tsx'], 'web has a test');
+ assert.match(out.files['apps/web/vite.config.ts'], /environment: 'jsdom'/);
+
+ // Same-origin /api in dev and prod.
+ assert.match(out.files['apps/web/vite.config.ts'], /'\/api': 'http:\/\/localhost:3000'/);
+ assert.match(out.files['apps/server/src/app.ts'], /serveStatic\(\{ root: '\.\.\/web\/dist' \}\)/);
+});
+
+test('fullstack: shared is built before the apps start, so dev has current types', () => {
+ const out = generate(fromPreset('fullstack', { name: 'acme' }));
+ const turbo = JSON.parse(out.files['turbo.json']);
+ assert.deepEqual(turbo.tasks.dev.dependsOn, ['^build']);
+ assert.equal(turbo.tasks.dev.persistent, true);
+});
+
+test('monorepo default layout is still the library one', () => {
+ const out = generate(fromPreset('monorepo', { name: 'libs' }));
+ assert.ok(out.files['packages/core/package.json']);
+ assert.equal(out.files['apps/web/package.json'], undefined);
+});
+
+test('packkit.json records only what differs from the defaults', () => {
+ const out = generate(fromPreset('node-service', { name: 'svc', generatorVersion: '9.9.9' }));
+ const prov = JSON.parse(out.files['packkit.json']);
+ assert.equal(prov.generator, 'create-packkit');
+ assert.equal(prov.version, '9.9.9');
+ assert.equal(prov.preset, 'node-service');
+ // Derived helpers and per-run choices aren't inputs, so they'd be misleading.
+ for (const k of ['isTs', 'hasApp', 'ext', 'gitInit', 'install', 'name']) {
+ assert.equal(prov.settings[k], undefined, `${k} should not be recorded`);
+ }
+ assert.ok(Object.keys(prov.settings).length > 0, 'a preset differs from defaults');
+});
+
+test('packkit.json is deterministic — same config, same bytes', () => {
+ const cfg = { name: 'x', generatorVersion: '1.0.0' };
+ assert.equal(
+ generate(fromPreset('ts-lib', cfg)).files['packkit.json'],
+ generate(fromPreset('ts-lib', cfg)).files['packkit.json'],
+ );
+});