@django-stack/cli 0.3.0 → 0.4.0

package/dist/bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { D as parseEnv, E as checkTools, O as setEnvValues, S as validateDomain, T as runDoctor, _ as toProjectName, a as decodePreset, b as CLI_VERSION, c as resolvePreset, d as LOCAL_S3, f as lockBackend, g as timeZones, h as scaffold, i as applies, l as stackOption, m as relativeDirectory, n as NAMED_PRESETS, o as encodePreset, r as STACK_OPTIONS, s as pendingChoices, t as DEFAULT_STACK, v as validateProjectName, w as generateSecret, x as productionEnv, y as validateTimeZone } from "./stack-CTyqYWCV.js";
+import { D as parseEnv, E as checkTools, O as setEnvValues, S as validateDomain, T as runDoctor, _ as encodePreset, a as relativeDirectory, b as stackOption, c as toProjectName, d as CLI_VERSION, f as DEFAULT_STACK, g as decodePreset, h as applies, l as validateProjectName, m as STACK_OPTIONS, n as LOCAL_S3, o as scaffold, p as NAMED_PRESETS, r as lockBackend, s as timeZones, u as validateTimeZone, v as pendingChoices, w as generateSecret, x as productionEnv, y as resolvePreset } from "./scaffold-DbgGYEsc.js";
 import { createRequire } from "node:module";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, delimiter, dirname, join, resolve } from "node:path";
@@ -2346,7 +2346,7 @@ async function init(directoryArgument, options) {
 		result = scaffold({
 			directory: target,
 			name,
-			frontend: "astro",
+			frontend: stack.frontend,
 			demoContent,
 			databaseUrl,
 			localS3: stack.storage === "s3",
@@ -2760,7 +2760,7 @@ function checkSteps(project, tests) {
 			devOnly: true
 		},
 		{
-			name: "Astro check",
+			name: "Frontend check",
 			service: "frontend",
 			args: [
 				"npm",

package/dist/index.d.ts

@@ -32,45 +32,6 @@ export declare function validateDomain(domain: string): string | undefined;
  * laptop works on the server.
  */
 export declare function productionEnv(devEnv: string, options: ProductionOptions): ProductionEnv;
-export declare const FRONTENDS: readonly ["astro"];
-type Frontend = (typeof FRONTENDS)[number];
-interface ScaffoldOptions {
-  /** The directory to create the project in. */
-  directory: string;
-  /** The project name: lowercase letters, digits and dashes. */
-  name: string;
-  frontend: Frontend;
-  /** Demo pages and posts on the first start. */
-  demoContent: boolean;
-  /** An external Postgres URL; the bundled Postgres when not set. */
-  databaseUrl?: string;
-  /** Store uploads in the local S3 service in development, like S3 in production. */
-  localS3?: boolean;
-  /** A DjangoStack monorepo to take the packages from instead of the registries (for development). */
-  link?: string;
-  /** The time zone of the backend, such as Europe/Amsterdam. UTC by default. */
-  timeZone?: string;
-  /** The preset code of the stack, saved in package.json for `config`. */
-  preset?: string;
-  /** Where the templates are; the ones in the package by default. */
-  templatesDir?: string;
-}
-interface ScaffoldResult {
-  directory: string;
-  adminUsername: string;
-  adminPassword: string;
-  files: number;
-}
-/** A valid project name from a directory name: `My Site` becomes `my-site`. */
-export declare function toProjectName(value: string): string;
-export declare function validateProjectName(value: string): string | undefined;
-/** Postgres URLs for hosts other than this machine must use TLS. */
-export declare function normalizeDatabaseUrl(url: string): string;
-export declare function scaffold(options: ScaffoldOptions): ScaffoldResult;
-/** A URL-safe random secret with `bytes` bytes of randomness. */
-export declare function generateSecret(bytes?: number): string;
-/** The secrets a project's .env needs, by the name used in `{{secret:<name>}}`. */
-export declare function generateProjectSecrets(): Record<string, string>;
 export declare const STACK_OPTIONS: readonly [{
   readonly key: "frontend";
   readonly flag: "--frontend";
@@ -85,7 +46,7 @@ export declare const STACK_OPTIONS: readonly [{
     readonly value: "next";
     readonly label: "Next.js";
     readonly hint: "React, server components";
-    readonly generated: false;
+    readonly generated: true;
   }, {
     readonly value: "headless";
     readonly label: "Headless";
@@ -96,6 +57,16 @@ export declare const STACK_OPTIONS: readonly [{
     readonly label: "Django templates";
     readonly hint: "no Node, Django renders the site";
     readonly generated: false;
+  }, {
+    readonly value: "nuxt";
+    readonly label: "Nuxt";
+    readonly hint: "Vue, server-rendered";
+    readonly generated: true;
+  }, {
+    readonly value: "sveltekit";
+    readonly label: "SvelteKit";
+    readonly hint: "Svelte, server-rendered";
+    readonly generated: true;
   }];
 }, {
   readonly key: "postgres";
@@ -248,6 +219,47 @@ export declare function pendingChoices(stack: Stack): {
   choice: string;
   isDefault: boolean;
 }[];
+/** A frontend option; its template is `templates/frontend-<name>`. */
+type Frontend = Stack["frontend"];
+/** The frontends this version of the CLI generates. */
+export declare const FRONTENDS: readonly Frontend[];
+interface ScaffoldOptions {
+  /** The directory to create the project in. */
+  directory: string;
+  /** The project name: lowercase letters, digits and dashes. */
+  name: string;
+  frontend: Frontend;
+  /** Demo pages and posts on the first start. */
+  demoContent: boolean;
+  /** An external Postgres URL; the bundled Postgres when not set. */
+  databaseUrl?: string;
+  /** Store uploads in the local S3 service in development, like S3 in production. */
+  localS3?: boolean;
+  /** A DjangoStack monorepo to take the packages from instead of the registries (for development). */
+  link?: string;
+  /** The time zone of the backend, such as Europe/Amsterdam. UTC by default. */
+  timeZone?: string;
+  /** The preset code of the stack, saved in package.json for `config`. */
+  preset?: string;
+  /** Where the templates are; the ones in the package by default. */
+  templatesDir?: string;
+}
+interface ScaffoldResult {
+  directory: string;
+  adminUsername: string;
+  adminPassword: string;
+  files: number;
+}
+/** A valid project name from a directory name: `My Site` becomes `my-site`. */
+export declare function toProjectName(value: string): string;
+export declare function validateProjectName(value: string): string | undefined;
+/** Postgres URLs for hosts other than this machine must use TLS. */
+export declare function normalizeDatabaseUrl(url: string): string;
+export declare function scaffold(options: ScaffoldOptions): ScaffoldResult;
+/** A URL-safe random secret with `bytes` bytes of randomness. */
+export declare function generateSecret(bytes?: number): string;
+/** The secrets a project's .env needs, by the name used in `{{secret:<name>}}`. */
+export declare function generateProjectSecrets(): Record<string, string>;
 /** The version of this package, the same for every @django-stack package. */
 declare const CLI_VERSION: string;
 export { type Check, type Frontend, type ProductionEnv, type ProductionOptions, type ScaffoldOptions, type ScaffoldResult, type Stack, CLI_VERSION as VERSION };

package/dist/index.js

@@ -1 +1 @@
-export { t as DEFAULT_STACK, u as FRONTENDS, n as NAMED_PRESETS, r as STACK_OPTIONS, b as VERSION, a as decodePreset, o as encodePreset, C as generateProjectSecrets, w as generateSecret, p as normalizeDatabaseUrl, D as parseEnv, s as pendingChoices, x as productionEnv, c as resolvePreset, T as runDoctor, h as scaffold, O as setEnvValues, _ as toProjectName, S as validateDomain, v as validateProjectName } from "./stack-CTyqYWCV.js";
+export { f as DEFAULT_STACK, t as FRONTENDS, p as NAMED_PRESETS, m as STACK_OPTIONS, d as VERSION, g as decodePreset, _ as encodePreset, C as generateProjectSecrets, w as generateSecret, i as normalizeDatabaseUrl, D as parseEnv, v as pendingChoices, x as productionEnv, y as resolvePreset, T as runDoctor, o as scaffold, O as setEnvValues, c as toProjectName, S as validateDomain, l as validateProjectName } from "./scaffold-DbgGYEsc.js";

package/dist/{stack-CTyqYWCV.js → scaffold-DbgGYEsc.js}

@@ -348,186 +348,6 @@ function productionEnv(devEnv, options) {
 		todo
 	};
 }
-// src/version.ts
-/** The version of this package, the same for every @django-stack package. */
-const CLI_VERSION = createRequire(import.meta.url)("../package.json").version;
-// src/scaffold.ts
-const FRONTENDS = ["astro"];
-/** The local S3 service of the `s3` profile. It accepts any credentials. */
-const LOCAL_S3 = {
-	S3_BUCKET: "media",
-	S3_ENDPOINT_URL: "http://s3:8333",
-	S3_REGION: "us-east-1",
-	S3_ACCESS_KEY_ID: "local",
-	S3_SECRET_ACCESS_KEY: "local",
-	S3_PUBLIC_URL: "http://localhost:8333/media",
-	S3_CREATE_BUCKET: "1"
-};
-const TEXT_EXTENSIONS = /\.(py|ts|mjs|js|json|astro|css|md|yaml|yml|toml|txt|html|sh|svg)$|Dockerfile$|gitignore$|\.dockerignore$|env\.example$/;
-function defaultTemplatesDir() {
-	return fileURLToPath(new URL("../templates", import.meta.url));
-}
-/** A valid project name from a directory name: `My Site` becomes `my-site`. */
-function toProjectName(value) {
-	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
-}
-function validateProjectName(value) {
-	if (!/^[a-z][a-z0-9-]{0,49}$/.test(value)) return "Use lowercase letters, digits and dashes, starting with a letter.";
-}
-/** Postgres URLs for hosts other than this machine must use TLS. */
-function normalizeDatabaseUrl(url) {
-	let parsed;
-	try {
-		parsed = new URL(url);
-	} catch {
-		throw new Error(`The database URL is not a URL: ${url}`);
-	}
-	if (!["postgres:", "postgresql:"].includes(parsed.protocol)) throw new Error("The database URL must start with postgres:// or postgresql://.");
-	if (![
-		"localhost",
-		"127.0.0.1",
-		"host.docker.internal",
-		"db"
-	].includes(parsed.hostname) && !parsed.searchParams.has("sslmode")) parsed.searchParams.set("sslmode", "require");
-	return parsed.toString();
-}
-function walk(directory) {
-	return readdirSync(directory).flatMap((entry) => {
-		const path = join(directory, entry);
-		return statSync(path).isDirectory() ? walk(path) : [path];
-	});
-}
-function render(text, values) {
-	return text.replace(/\{\{([a-z_]+)\}\}/g, (match, key) => values[key] ?? match);
-}
-/** The IANA time zones Node knows, with UTC first. */
-function timeZones() {
-	return ["UTC", ...Intl.supportedValuesOf("timeZone").filter((zone) => zone !== "UTC")];
-}
-function validateTimeZone(value) {
-	if (timeZones().includes(value)) return void 0;
-	return `${JSON.stringify(value)} is not a time zone. Use a name such as Europe/Amsterdam or UTC.`;
-}
-function scaffold(options) {
-	const templates = options.templatesDir ?? defaultTemplatesDir();
-	const target = options.directory;
-	if (existsSync(target) && readdirSync(target).length > 0) throw new Error(`${target} exists and is not empty. Choose another directory.`);
-	const nameError = validateProjectName(options.name);
-	if (nameError) throw new Error(`The project name ${JSON.stringify(options.name)} is not valid. ${nameError}`);
-	if (options.timeZone) {
-		const zoneError = validateTimeZone(options.timeZone);
-		if (zoneError) throw new Error(zoneError);
-	}
-	mkdirSync(target, { recursive: true });
-	cpSync(join(templates, "base"), target, { recursive: true });
-	cpSync(join(templates, "backend"), join(target, "backend"), { recursive: true });
-	cpSync(join(templates, `frontend-${options.frontend}`), join(target, "frontend"), { recursive: true });
-	renameSync(join(target, "gitignore"), join(target, ".gitignore"));
-	const values = {
-		project_name: options.name,
-		frontend: options.frontend,
-		cli_version: CLI_VERSION,
-		preset: options.preset ?? "a"
-	};
-	const files = walk(target);
-	for (const file of files) {
-		if (!TEXT_EXTENSIONS.test(file)) continue;
-		const text = readFileSync(file, "utf8");
-		const rendered = render(text, values);
-		if (rendered !== text) writeFileSync(file, rendered);
-	}
-	if (options.timeZone && options.timeZone !== "UTC") {
-		const settings = join(target, "backend", "config", "settings.py");
-		const text = readFileSync(settings, "utf8");
-		writeFileSync(settings, text.replace("TIME_ZONE = \"UTC\"", `TIME_ZONE = ${JSON.stringify(options.timeZone)}`));
-	}
-	const template = readFileSync(join(target, "env.example"), "utf8");
-	const secrets = generateProjectSecrets();
-	let env = template.replace(/\{\{secret:([a-z_]+)\}\}/g, (match, key) => secrets[key] ?? match);
-	const envExample = template.replace(/\{\{secret:[a-z_]+\}\}/g, "");
-	const profiles = ["dev"];
-	if (options.databaseUrl) env = setEnvValues(env, { DATABASE_URL: normalizeDatabaseUrl(options.databaseUrl) });
-	else profiles.push("db");
-	if (options.localS3) {
-		profiles.push("s3");
-		env = setEnvValues(env, LOCAL_S3);
-	}
-	env = setEnvValues(env, { COMPOSE_PROFILES: profiles.join(",") });
-	if (!options.demoContent) env = setEnvValues(env, { SEED_DEMO_CONTENT: "0" });
-	writeFileSync(join(target, ".env"), env, { mode: 384 });
-	writeFileSync(join(target, ".env.example"), envExample);
-	rmSync(join(target, "env.example"));
-	if (options.link) linkPackages(target, options.link);
-	return {
-		directory: target,
-		adminUsername: "admin",
-		adminPassword: secrets.admin ?? "",
-		files: walk(target).length
-	};
-}
-/**
-* Development only: build django-stack and @django-stack/utils from a
-* monorepo checkout into the project's vendor/ directories and point the
-* dependencies at them, so a project can run before a release.
-*/
-function linkPackages(target, monorepo) {
-	const backendVendor = join(target, "backend", "vendor");
-	const frontendVendor = join(target, "frontend", "vendor");
-	mkdirSync(backendVendor, { recursive: true });
-	mkdirSync(frontendVendor, { recursive: true });
-	execFileSync("uv", [
-		"build",
-		"--wheel",
-		"--out-dir",
-		backendVendor
-	], {
-		cwd: join(monorepo, "python", "django-stack"),
-		stdio: "ignore"
-	});
-	rmSync(join(backendVendor, ".gitignore"), { force: true });
-	const wheel = readdirSync(backendVendor).find((file) => file.endsWith(".whl"));
-	if (!wheel) throw new Error("Building the django-stack wheel failed.");
-	const pyproject = join(target, "backend", "pyproject.toml");
-	writeFileSync(pyproject, `${readFileSync(pyproject, "utf8").trimEnd()}\n\n[tool.uv.sources]\ndjango-stack = { path = "vendor/${wheel}" }\n`);
-	execFileSync("pnpm", [
-		"--filter",
-		"@django-stack/utils",
-		"build"
-	], {
-		cwd: monorepo,
-		stdio: "ignore"
-	});
-	execFileSync("pnpm", [
-		"pack",
-		"--pack-destination",
-		frontendVendor
-	], {
-		cwd: join(monorepo, "packages", "utils"),
-		stdio: "ignore"
-	});
-	const tarball = readdirSync(frontendVendor).find((file) => file.endsWith(".tgz"));
-	if (!tarball) throw new Error("Packing @django-stack/utils failed.");
-	const packageJson = join(target, "frontend", "package.json");
-	const manifest = JSON.parse(readFileSync(packageJson, "utf8"));
-	manifest.dependencies["@django-stack/utils"] = `file:vendor/${tarball}`;
-	writeFileSync(packageJson, `${JSON.stringify(manifest, null, 2)}\n`);
-}
-/** Locks the backend's dependencies with uv, when uv is installed. */
-function lockBackend(target) {
-	try {
-		execFileSync("uv", ["lock", "--quiet"], {
-			cwd: join(target, "backend"),
-			stdio: "ignore"
-		});
-		return true;
-	} catch {
-		return false;
-	}
-}
-function relativeDirectory(directory) {
-	const path = relative(process.cwd(), directory) || ".";
-	return path.startsWith("..") ? directory : path;
-}
 // src/stack.ts
 const STACK_OPTIONS = [
 	{
@@ -546,7 +366,7 @@ const STACK_OPTIONS = [
 				value: "next",
 				label: "Next.js",
 				hint: "React, server components",
-				generated: false
+				generated: true
 			},
 			{
 				value: "headless",
@@ -559,6 +379,18 @@ const STACK_OPTIONS = [
 				label: "Django templates",
 				hint: "no Node, Django renders the site",
 				generated: false
+			},
+			{
+				value: "nuxt",
+				label: "Nuxt",
+				hint: "Vue, server-rendered",
+				generated: true
+			},
+			{
+				value: "sveltekit",
+				label: "SvelteKit",
+				hint: "Svelte, server-rendered",
+				generated: true
 			}
 		]
 	},
@@ -715,9 +547,16 @@ function stackOption(key) {
 	return option;
 }
 const DEFAULT_STACK = Object.fromEntries(STACK_OPTIONS.map((option) => [option.key, option.values[0].value]));
+/** The frontends that run on Node, with a `frontend/` directory and a package manager. */
+const NODE_FRONTENDS = [
+	"astro",
+	"next",
+	"nuxt",
+	"sveltekit"
+];
 /** Whether an option applies to a stack: the package manager only with a Node frontend. */
 function applies(key, stack) {
-	if (key === "packageManager") return stack.frontend === void 0 || ["astro", "next"].includes(stack.frontend);
+	if (key === "packageManager") return stack.frontend === void 0 || NODE_FRONTENDS.includes(stack.frontend);
 	return true;
 }
 /** The preset format version, the first character of a code. */
@@ -797,4 +636,198 @@ function pendingChoices(stack) {
 		}];
 	});
 }
-export { generateProjectSecrets as C, parseEnv as D, checkTools as E, setEnvValues as O, validateDomain as S, runDoctor as T, toProjectName as _, decodePreset as a, CLI_VERSION as b, resolvePreset as c, LOCAL_S3 as d, lockBackend as f, timeZones as g, scaffold as h, applies as i, stackOption as l, relativeDirectory as m, NAMED_PRESETS as n, encodePreset as o, normalizeDatabaseUrl as p, STACK_OPTIONS as r, pendingChoices as s, DEFAULT_STACK as t, FRONTENDS as u, validateProjectName as v, generateSecret as w, productionEnv as x, validateTimeZone as y };
+// src/version.ts
+/** The version of this package, the same for every @django-stack package. */
+const CLI_VERSION = createRequire(import.meta.url)("../package.json").version;
+// src/scaffold.ts
+/** The frontends this version of the CLI generates. */
+const FRONTENDS = stackOption("frontend").values.filter((value) => value.generated).map((value) => value.value);
+/** The local S3 service of the `s3` profile. It accepts any credentials. */
+const LOCAL_S3 = {
+	S3_BUCKET: "media",
+	S3_ENDPOINT_URL: "http://s3:8333",
+	S3_REGION: "us-east-1",
+	S3_ACCESS_KEY_ID: "local",
+	S3_SECRET_ACCESS_KEY: "local",
+	S3_PUBLIC_URL: "http://localhost:8333/media",
+	S3_CREATE_BUCKET: "1"
+};
+const TEXT_EXTENSIONS = /\.(py|ts|tsx|mjs|js|jsx|json|astro|vue|svelte|css|md|yaml|yml|toml|txt|html|sh|svg)$|Dockerfile$|gitignore$|\.dockerignore$|env\.example$/;
+function defaultTemplatesDir() {
+	return fileURLToPath(new URL("../templates", import.meta.url));
+}
+/** A valid project name from a directory name: `My Site` becomes `my-site`. */
+function toProjectName(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50);
+}
+function validateProjectName(value) {
+	if (!/^[a-z][a-z0-9-]{0,49}$/.test(value)) return "Use lowercase letters, digits and dashes, starting with a letter.";
+}
+/** Postgres URLs for hosts other than this machine must use TLS. */
+function normalizeDatabaseUrl(url) {
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new Error(`The database URL is not a URL: ${url}`);
+	}
+	if (!["postgres:", "postgresql:"].includes(parsed.protocol)) throw new Error("The database URL must start with postgres:// or postgresql://.");
+	if (![
+		"localhost",
+		"127.0.0.1",
+		"host.docker.internal",
+		"db"
+	].includes(parsed.hostname) && !parsed.searchParams.has("sslmode")) parsed.searchParams.set("sslmode", "require");
+	return parsed.toString();
+}
+function walk(directory) {
+	return readdirSync(directory).flatMap((entry) => {
+		const path = join(directory, entry);
+		return statSync(path).isDirectory() ? walk(path) : [path];
+	});
+}
+function render(text, values) {
+	return text.replace(/\{\{([a-z_]+)\}\}/g, (match, key) => values[key] ?? match);
+}
+/** The IANA time zones Node knows, with UTC first. */
+function timeZones() {
+	return ["UTC", ...Intl.supportedValuesOf("timeZone").filter((zone) => zone !== "UTC")];
+}
+function validateTimeZone(value) {
+	if (timeZones().includes(value)) return void 0;
+	return `${JSON.stringify(value)} is not a time zone. Use a name such as Europe/Amsterdam or UTC.`;
+}
+function scaffold(options) {
+	const templates = options.templatesDir ?? defaultTemplatesDir();
+	const target = options.directory;
+	if (existsSync(target) && readdirSync(target).length > 0) throw new Error(`${target} exists and is not empty. Choose another directory.`);
+	const nameError = validateProjectName(options.name);
+	if (nameError) throw new Error(`The project name ${JSON.stringify(options.name)} is not valid. ${nameError}`);
+	if (options.timeZone) {
+		const zoneError = validateTimeZone(options.timeZone);
+		if (zoneError) throw new Error(zoneError);
+	}
+	const frontendTemplate = join(templates, `frontend-${options.frontend}`);
+	if (!existsSync(frontendTemplate)) throw new Error(`This version of the CLI has no ${options.frontend} frontend.`);
+	mkdirSync(target, { recursive: true });
+	cpSync(join(templates, "base"), target, { recursive: true });
+	cpSync(join(templates, "backend"), join(target, "backend"), { recursive: true });
+	cpSync(frontendTemplate, join(target, "frontend"), { recursive: true });
+	renameSync(join(target, "gitignore"), join(target, ".gitignore"));
+	const about = join(target, "frontend", "template.json");
+	const frontend = JSON.parse(readFileSync(about, "utf8"));
+	rmSync(about);
+	const values = {
+		project_name: options.name,
+		frontend: options.frontend,
+		frontend_label: frontend.label,
+		frontend_url: frontend.url,
+		frontend_security: frontend.security,
+		cli_version: CLI_VERSION,
+		preset: options.preset ?? "a"
+	};
+	const files = walk(target);
+	for (const file of files) {
+		if (!TEXT_EXTENSIONS.test(file)) continue;
+		const text = readFileSync(file, "utf8");
+		const rendered = render(text, values);
+		if (rendered !== text) writeFileSync(file, rendered);
+	}
+	if (options.timeZone && options.timeZone !== "UTC") {
+		const settings = join(target, "backend", "config", "settings.py");
+		const text = readFileSync(settings, "utf8");
+		writeFileSync(settings, text.replace("TIME_ZONE = \"UTC\"", `TIME_ZONE = ${JSON.stringify(options.timeZone)}`));
+	}
+	const template = readFileSync(join(target, "env.example"), "utf8");
+	const secrets = generateProjectSecrets();
+	let env = template.replace(/\{\{secret:([a-z_]+)\}\}/g, (match, key) => secrets[key] ?? match);
+	const envExample = template.replace(/\{\{secret:[a-z_]+\}\}/g, "");
+	const profiles = ["dev"];
+	if (options.databaseUrl) env = setEnvValues(env, { DATABASE_URL: normalizeDatabaseUrl(options.databaseUrl) });
+	else profiles.push("db");
+	if (options.localS3) {
+		profiles.push("s3");
+		env = setEnvValues(env, LOCAL_S3);
+	}
+	env = setEnvValues(env, { COMPOSE_PROFILES: profiles.join(",") });
+	if (!options.demoContent) env = setEnvValues(env, { SEED_DEMO_CONTENT: "0" });
+	writeFileSync(join(target, ".env"), env, { mode: 384 });
+	writeFileSync(join(target, ".env.example"), envExample);
+	rmSync(join(target, "env.example"));
+	if (options.link) linkPackages(target, options.link);
+	return {
+		directory: target,
+		adminUsername: "admin",
+		adminPassword: secrets.admin ?? "",
+		files: walk(target).length
+	};
+}
+/**
+* Development only: build django-stack and the @django-stack packages from a
+* monorepo checkout into the project's vendor/ directories and point the
+* dependencies at them, so a project can run before a release.
+*/
+function linkPackages(target, monorepo) {
+	const backendVendor = join(target, "backend", "vendor");
+	const frontendVendor = join(target, "frontend", "vendor");
+	mkdirSync(backendVendor, { recursive: true });
+	mkdirSync(frontendVendor, { recursive: true });
+	execFileSync("uv", [
+		"build",
+		"--wheel",
+		"--out-dir",
+		backendVendor
+	], {
+		cwd: join(monorepo, "python", "django-stack"),
+		stdio: "ignore"
+	});
+	rmSync(join(backendVendor, ".gitignore"), { force: true });
+	const wheel = readdirSync(backendVendor).find((file) => file.endsWith(".whl"));
+	if (!wheel) throw new Error("Building the django-stack wheel failed.");
+	const pyproject = join(target, "backend", "pyproject.toml");
+	writeFileSync(pyproject, `${readFileSync(pyproject, "utf8").trimEnd()}\n\n[tool.uv.sources]\ndjango-stack = { path = "vendor/${wheel}" }\n`);
+	const packageJson = join(target, "frontend", "package.json");
+	const manifest = JSON.parse(readFileSync(packageJson, "utf8"));
+	const packages = Object.keys(manifest.dependencies ?? {}).filter((name) => name.startsWith("@django-stack/"));
+	for (const name of packages) {
+		const directory = join(monorepo, "packages", name.slice(14));
+		execFileSync("pnpm", [
+			"--filter",
+			name,
+			"build"
+		], {
+			cwd: monorepo,
+			stdio: "ignore"
+		});
+		const before = new Set(readdirSync(frontendVendor));
+		execFileSync("pnpm", [
+			"pack",
+			"--pack-destination",
+			frontendVendor
+		], {
+			cwd: directory,
+			stdio: "ignore"
+		});
+		const tarball = readdirSync(frontendVendor).find((file) => file.endsWith(".tgz") && !before.has(file));
+		if (!tarball) throw new Error(`Packing ${name} failed.`);
+		manifest.dependencies[name] = `file:vendor/${tarball}`;
+	}
+	writeFileSync(packageJson, `${JSON.stringify(manifest, null, 2)}\n`);
+}
+/** Locks the backend's dependencies with uv, when uv is installed. */
+function lockBackend(target) {
+	try {
+		execFileSync("uv", ["lock", "--quiet"], {
+			cwd: join(target, "backend"),
+			stdio: "ignore"
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function relativeDirectory(directory) {
+	const path = relative(process.cwd(), directory) || ".";
+	return path.startsWith("..") ? directory : path;
+}
+export { generateProjectSecrets as C, parseEnv as D, checkTools as E, setEnvValues as O, validateDomain as S, runDoctor as T, encodePreset as _, relativeDirectory as a, stackOption as b, toProjectName as c, CLI_VERSION as d, DEFAULT_STACK as f, decodePreset as g, applies as h, normalizeDatabaseUrl as i, validateProjectName as l, STACK_OPTIONS as m, LOCAL_S3 as n, scaffold as o, NAMED_PRESETS as p, lockBackend as r, timeZones as s, FRONTENDS as t, validateTimeZone as u, pendingChoices as v, generateSecret as w, productionEnv as x, resolvePreset as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@django-stack/cli",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "The production-ready Django, batteries included stack. Create and manage DjangoStack projects: a Django backend, a frontend, Postgres and Docker Compose in one command.",
   "license": "MIT",
   "author": "Leon van der Grient",

package/templates/backend/pyproject.toml

@@ -5,7 +5,7 @@ description = "The Django backend of {{project_name}}."
 requires-python = ">=3.12"
 dependencies = [
     "Django>=6.1,<6.2",
-    "django-stack[server,s3]>=0.3.0",
+    "django-stack[server,s3]>=0.4.0",
     "django-headless[schema]>=1.1.1",
     "django-content-studio[images,huey]>=1.8.0",
 ]

package/templates/base/AGENTS.md

@@ -1,8 +1,9 @@
 # {{project_name}}: guide for AI agents
 
 A website built with DjangoStack: a Django backend (Django Headless serves
-the content API, Django Content Studio is the admin) and an Astro frontend
-that renders the content, run with Docker Compose.
+the content API, Django Content Studio is the admin) and a frontend built
+with {{frontend_label}} that renders the content, run with Docker Compose.
+`frontend/AGENTS.md` describes the frontend.
 
 ## Layout
 
@@ -15,12 +16,8 @@ backend/                 Django project
   content/admin.py       how each model looks in the admin (studios)
   content/seed.py        demo content
   content/tests/         pytest tests of the API
-frontend/                Astro site (server output, Node adapter)
-  src/pages/             routes: /, /[...slug], /blog, /blog/[slug], /category/[slug], /tag/[slug], sitemap.xml, rss.xml, robots.txt, /preview, /revalidate
-  src/components/        Blocks.astro maps block types to components in components/blocks/
-  src/lib/api.ts         getContent(): content helpers with the read-only key, drafts in preview
+frontend/                the {{frontend_label}} site; frontend/AGENTS.md lists its files
   src/lib/headless.ts    generated API types; do not edit, run `npm run generate:types`
-  src/middleware.ts      page cache, editor-managed redirects, security headers
 compose.yaml             every service; COMPOSE_PROFILES in .env picks dev or prod
 Caddyfile                the prod profile's reverse proxy and HTTPS
 .github/workflows/deploy.yml  optional deploy to a server over SSH
@@ -56,16 +53,15 @@ in a running container.
    `ModelStudio`.
 3. Run `makemigrations`; the backend migrates on its next start, or run
    `migrate`.
-4. Run `npm run generate:types`, then read it in the frontend through
-   `getClient()` from `src/lib/api.ts`: `getClient(Astro.cookies).model("content.mymodel").list()`.
+4. Run `npm run generate:types`, then read it in the frontend as
+   `frontend/AGENTS.md` shows.
 5. Add an API smoke test to `backend/content/tests/test_api.py`.
 
 ## How to add a block type
 
 1. Add a `Block` subclass in `backend/content/blocks.py` and add it to
    `BODY_BLOCKS`. Blocks need no migration.
-2. Add a component in `frontend/src/components/blocks/` and map the block's
-   type in `frontend/src/components/Blocks.astro`.
+2. Render it in the frontend as `frontend/AGENTS.md` shows.
 
 ## Rules
 

package/templates/base/README.md

@@ -1,11 +1,11 @@
 # {{project_name}}
 
-A website with a Django backend and an Astro frontend, created with
+A website with a Django backend and a frontend built with {{frontend_label}}, created with
 [DjangoStack](https://github.com/dwarsbit/django-stack).
 
 - [Django Headless](https://djangoheadless.org) serves the content API.
 - [Django Content Studio](https://djangocontentstudio.org) is the admin.
-- [Astro](https://astro.build) renders the site.
+- [{{frontend_label}}]({{frontend_url}}) renders the site.
 - Postgres stores the content; Valkey is the cache and task queue.
 
 ## Start
@@ -26,7 +26,7 @@ content. Edit a page in the admin, publish, and reload the site.
 ## Develop
 
 Both sides reload on save: the backend runs Django's development server and
-the frontend Astro's, with the source mounted from `backend/` and
+the frontend {{frontend_label}}'s, with the source mounted from `backend/` and
 `frontend/`. `AGENTS.md` lists the layout and the commands.
 
 | Task | Command |