create-better-fullstack 2.1.4 → 2.1.6

package/dist/scaffold-manifest-GV1fbhpD.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+import fs from "fs-extra";
+import path from "node:path";
+import { createHash } from "node:crypto";
+
+//#region src/utils/scaffold-manifest.ts
+/**
+* Scaffold baseline manifest ("bts.lock.json").
+*
+* Recorded once at create time (after formatting, before install) as a map of
+* every on-disk file path -> sha256 of its bytes. `bfs update` later re-renders
+* the project with the current templates and uses this baseline to tell apart
+* three cases per file: the template moved but the file was never touched (safe
+* to patch), the user edited the file (keep as-is), or both changed (conflict).
+* Without a recorded baseline that distinction is impossible.
+*/
+const SCAFFOLD_MANIFEST_FILE = "bts.lock.json";
+const MANIFEST_VERSION = "1";
+/** Directories never worth hashing (dependencies / VCS metadata). */
+const EXCLUDED_DIR_NAMES = new Set(["node_modules", ".git"]);
+/**
+* Files whose on-disk bytes are NOT a pure-template render — the manifest
+* itself, the config file (regenerated on update), and package-manager /
+* toolchain lockfiles that install mutates. Excluding them keeps the baseline
+* focused on template-comparable content so `bfs update` never mistakes an
+* install artifact for template drift.
+*/
+const EXCLUDED_FILE_NAMES = new Set([
+	SCAFFOLD_MANIFEST_FILE,
+	"bts.jsonc",
+	"bun.lock",
+	"bun.lockb",
+	"package-lock.json",
+	"pnpm-lock.yaml",
+	"yarn.lock",
+	"Cargo.lock",
+	"uv.lock",
+	"poetry.lock",
+	"go.sum",
+	"mix.lock"
+]);
+function hashContent(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+function toPosixRelative(rootDir, fullPath) {
+	return path.relative(rootDir, fullPath).split(path.sep).join("/");
+}
+async function walkFiles(rootDir) {
+	const results = [];
+	async function walk(dir) {
+		let entries;
+		try {
+			entries = await fs.readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if (EXCLUDED_DIR_NAMES.has(entry.name)) continue;
+				await walk(fullPath);
+			} else if (entry.isFile()) {
+				if (EXCLUDED_FILE_NAMES.has(entry.name)) continue;
+				results.push(fullPath);
+			}
+		}
+	}
+	await walk(rootDir);
+	return results;
+}
+/** Walk the project on disk and return a deterministic path -> sha256 map. */
+async function computeScaffoldHashes(projectDir) {
+	const files = await walkFiles(projectDir);
+	const entries = await Promise.all(files.map(async (fullPath) => {
+		const bytes = await fs.readFile(fullPath);
+		return [toPosixRelative(projectDir, fullPath), hashContent(bytes)];
+	}));
+	return Object.fromEntries(entries.sort(([a], [b]) => a.localeCompare(b)));
+}
+async function writeScaffoldManifest(projectDir, manifest) {
+	const sorted = {
+		version: manifest.version,
+		createdAt: manifest.createdAt,
+		hashes: Object.fromEntries(Object.entries(manifest.hashes).sort(([a], [b]) => a.localeCompare(b)))
+	};
+	const manifestPath = path.join(projectDir, SCAFFOLD_MANIFEST_FILE);
+	await fs.writeFile(manifestPath, `${JSON.stringify(sorted, null, 2)}\n`, "utf-8");
+}
+/**
+* Record the scaffold baseline manifest for a freshly created project.
+*
+* Best-effort by design: any failure returns null instead of throwing, so a
+* problem here can only disable `bfs update`'s auto-patching — it must never
+* break the create path.
+*/
+async function recordScaffoldManifest(projectDir, metadata = {}) {
+	try {
+		const manifest = {
+			version: MANIFEST_VERSION,
+			createdAt: metadata.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+			hashes: await computeScaffoldHashes(projectDir)
+		};
+		await writeScaffoldManifest(projectDir, manifest);
+		return manifest;
+	} catch {
+		return null;
+	}
+}
+async function readScaffoldManifest(projectDir) {
+	try {
+		const manifestPath = path.join(projectDir, SCAFFOLD_MANIFEST_FILE);
+		if (!await fs.pathExists(manifestPath)) return null;
+		const raw = await fs.readFile(manifestPath, "utf-8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || typeof parsed.hashes !== "object") return null;
+		return parsed;
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+export { writeScaffoldManifest as i, readScaffoldManifest as n, recordScaffoldManifest as r, hashContent as t };

package/dist/update-C9_x2yBF.mjs

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+import { r as readBtsConfig } from "./bts-config-BceXPcpI.mjs";
+import { t as renderTitle } from "./render-title-zvyKC1ej.mjs";
+import { a as handleError } from "./errors-ns_o2OKg.mjs";
+import "./file-formatter-XU6ti05V.mjs";
+import { i as writeScaffoldManifest, n as readScaffoldManifest, r as recordScaffoldManifest, t as hashContent } from "./scaffold-manifest-GV1fbhpD.mjs";
+import { c as formatGeneratedTree, d as treeToFileMap, l as generateTree, s as configFromBtsConfig } from "./mcp-entry.mjs";
+import { intro, log, outro } from "@clack/prompts";
+import pc from "picocolors";
+import fs from "fs-extra";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { writeSelectedFiles } from "@better-fullstack/template-generator/fs-writer";
+
+//#region src/helpers/core/scaffold-upgrade.ts
+const BINARY_FILE_MARKER = "[Binary file]";
+/**
+* Files whose on-disk bytes are mutated by create-time post-processing
+* (package-manager version, dependency version channel, db-setup, addons) or by
+* dependency install, so their scaffold baseline is not a pure-template render.
+* Never auto-patched — always routed to manual review. A structured merge
+* (reusing stack-update's mergePackageJson / mergeEnvExample) is a deferred
+* follow-up; the MVP is conservative to avoid clobbering post-processed deps.
+*/
+function isStructuredMergeFile(relPath) {
+	const name = path.basename(relPath);
+	return name === "package.json" || name === ".env" || name.endsWith(".env.example") || name === "bun.lock" || name === "bun.lockb" || name === "package-lock.json" || name === "pnpm-lock.yaml" || name === "yarn.lock";
+}
+/**
+* Generated docs (README) are re-derived from project mode / stack summary at
+* render time, so their bytes legitimately differ between the create-time
+* render and a later re-render even when untouched. Mirror stack-update's
+* isSkippableGeneratedDoc: never auto-patch them, and never flag them as drift.
+*/
+function isSkippableDoc(relPath) {
+	return path.basename(relPath).toLowerCase() === "readme.md";
+}
+async function inferProjectName(projectDir) {
+	const packageJson = await fs.readJson(path.join(projectDir, "package.json")).catch(() => null);
+	if (packageJson && typeof packageJson.name === "string" && packageJson.name.trim()) return packageJson.name.trim();
+	return path.basename(projectDir);
+}
+/**
+* Render the project with the current bundled templates and return a
+* deterministic path -> sha256 map of the formatted output. Text files hash
+* their formatted content directly; binary files are materialized to a temp
+* dir (mirroring how create writes them) and hashed from bytes.
+*/
+async function computeRenderHashes(tree) {
+	const fileMap = treeToFileMap(tree);
+	const hashes = /* @__PURE__ */ new Map();
+	const binaryPaths = [];
+	for (const [filePath, file] of fileMap) if (file.content === BINARY_FILE_MARKER) binaryPaths.push(filePath);
+	else hashes.set(filePath, hashContent(Buffer.from(file.content, "utf-8")));
+	if (binaryPaths.length > 0) {
+		const binarySet = new Set(binaryPaths);
+		const tempDir = await fs.mkdtemp(path.join(tmpdir(), "bfs-update-binary-"));
+		try {
+			const written = await writeSelectedFiles(tree, tempDir, (candidate) => binarySet.has(candidate));
+			for (const filePath of written) {
+				const bytes = await fs.readFile(path.join(tempDir, filePath));
+				hashes.set(filePath, hashContent(bytes));
+			}
+		} finally {
+			await fs.rm(tempDir, {
+				recursive: true,
+				force: true
+			});
+		}
+	}
+	return hashes;
+}
+async function renderCurrentProject(projectDir) {
+	const btsConfig = await readBtsConfig(projectDir);
+	if (!btsConfig) return { error: `No bts.jsonc found in ${projectDir}. Is this a Better Fullstack project?` };
+	const currentConfig = configFromBtsConfig(btsConfig, projectDir, await inferProjectName(projectDir));
+	try {
+		const tree = await generateTree(currentConfig);
+		await formatGeneratedTree(tree);
+		return {
+			tree,
+			renderHashes: await computeRenderHashes(tree)
+		};
+	} catch (error) {
+		return { error: `Failed to render current templates: ${error instanceof Error ? error.message : String(error)}` };
+	}
+}
+function summarize(projectDir, files, manifest) {
+	const byCategory = (category) => files.filter((file) => file.category === category).map((file) => file.path);
+	const drift = byCategory("drift");
+	const newFiles = byCategory("new-file");
+	return {
+		success: true,
+		projectDir,
+		hasBaseline: manifest !== null,
+		baselineCreatedAt: manifest?.createdAt,
+		files,
+		unchanged: byCategory("unchanged"),
+		drift,
+		userEdited: byCategory("user-edited"),
+		conflicts: byCategory("conflict"),
+		manual: files.filter((file) => file.category === "manual"),
+		newFiles,
+		removed: byCategory("removed"),
+		actionable: [...drift, ...newFiles].sort()
+	};
+}
+/**
+* Classify every current-template file against the on-disk project and the
+* recorded scaffold baseline. Pure read-only planning — writes nothing.
+*/
+async function planScaffoldUpgrade(projectDirInput) {
+	const projectDir = path.resolve(projectDirInput);
+	const rendered = await renderCurrentProject(projectDir);
+	if ("error" in rendered) return {
+		success: false,
+		projectDir,
+		error: rendered.error
+	};
+	const { renderHashes } = rendered;
+	const manifest = await readScaffoldManifest(projectDir);
+	const baseline = manifest?.hashes ?? {};
+	const hasBaseline = manifest !== null;
+	const files = [];
+	const renderPaths = [...renderHashes.keys()].sort();
+	for (const filePath of renderPaths) {
+		const renderHash = renderHashes.get(filePath);
+		const fullPath = path.join(projectDir, filePath);
+		if (!await fs.pathExists(fullPath)) {
+			if (baseline[filePath] !== void 0) {
+				files.push({
+					path: filePath,
+					category: "user-edited",
+					reason: "deleted locally"
+				});
+				continue;
+			}
+			files.push({
+				path: filePath,
+				category: "new-file"
+			});
+			continue;
+		}
+		const diskBytes = await fs.readFile(fullPath).catch(() => void 0);
+		if (!diskBytes) {
+			files.push({
+				path: filePath,
+				category: "manual",
+				reason: "unreadable on disk"
+			});
+			continue;
+		}
+		const diskHash = hashContent(diskBytes);
+		if (diskHash === renderHash) {
+			files.push({
+				path: filePath,
+				category: "unchanged"
+			});
+			continue;
+		}
+		if (isSkippableDoc(filePath)) continue;
+		if (isStructuredMergeFile(filePath)) {
+			files.push({
+				path: filePath,
+				category: "manual",
+				reason: "post-processed file — merge dependencies/env by hand"
+			});
+			continue;
+		}
+		const baselineHash = baseline[filePath];
+		if (baselineHash === void 0) {
+			files.push({
+				path: filePath,
+				category: "manual",
+				reason: hasBaseline ? "no baseline recorded for this file" : "no scaffold baseline — run `update --record-baseline` first"
+			});
+			continue;
+		}
+		if (diskHash === baselineHash) {
+			files.push({
+				path: filePath,
+				category: "drift"
+			});
+			continue;
+		}
+		if (renderHash === baselineHash) {
+			files.push({
+				path: filePath,
+				category: "user-edited"
+			});
+			continue;
+		}
+		files.push({
+			path: filePath,
+			category: "conflict",
+			reason: "both the template and your local copy changed"
+		});
+	}
+	const renderPathSet = new Set(renderPaths);
+	const removed = [];
+	for (const baselinePath of Object.keys(baseline)) {
+		if (renderPathSet.has(baselinePath) || isStructuredMergeFile(baselinePath)) continue;
+		if (await fs.pathExists(path.join(projectDir, baselinePath))) removed.push(baselinePath);
+	}
+	for (const removedPath of removed.sort()) files.push({
+		path: removedPath,
+		category: "removed",
+		reason: "no longer produced by the current templates (not auto-deleted)"
+	});
+	return summarize(projectDir, files, manifest);
+}
+/**
+* Apply the safe part of the plan: overwrite template-drift files and write
+* brand-new template files, then refresh the baseline for every file that now
+* matches the current render. Conflicts, local edits, and post-processed files
+* are left untouched (and reported by the caller for manual review).
+*/
+async function applyScaffoldUpgrade(projectDirInput) {
+	const plan = await planScaffoldUpgrade(projectDirInput);
+	if (!plan.success) return plan;
+	const { projectDir } = plan;
+	const rendered = await renderCurrentProject(projectDir);
+	if ("error" in rendered) return {
+		success: false,
+		projectDir,
+		error: rendered.error
+	};
+	const { tree, renderHashes } = rendered;
+	const toWrite = new Set([...plan.drift, ...plan.newFiles]);
+	if (toWrite.size > 0) await writeSelectedFiles(tree, projectDir, (candidate) => toWrite.has(candidate));
+	const manifest = await readScaffoldManifest(projectDir);
+	if (manifest) {
+		for (const filePath of new Set([...plan.unchanged, ...toWrite])) {
+			const renderHash = renderHashes.get(filePath);
+			if (renderHash) manifest.hashes[filePath] = renderHash;
+		}
+		await writeScaffoldManifest(projectDir, manifest);
+	}
+	return {
+		...plan,
+		applied: {
+			patched: [...plan.drift],
+			added: [...plan.newFiles]
+		}
+	};
+}
+
+//#endregion
+//#region src/commands/update.ts
+function formatCount(count, noun) {
+	return `${count} ${noun}${count === 1 ? "" : "s"}`;
+}
+function failUpdate(projectDir, error, json) {
+	if (json) {
+		console.log(JSON.stringify({
+			projectDir,
+			ok: false,
+			error
+		}, null, 2));
+		process.exit(1);
+	}
+	handleError(error);
+}
+function reportGroup(title, marker, entries) {
+	if (entries.length === 0) return;
+	log.message(`${title} (${entries.length}):`);
+	for (const entry of entries) log.message(pc.dim(`  ${marker} ${entry}`));
+}
+function reportManual(entries) {
+	if (entries.length === 0) return;
+	log.message(`Needs manual review (${entries.length}):`);
+	for (const entry of entries) log.message(pc.dim(`  ! ${entry.path}${entry.reason ? ` — ${entry.reason}` : ""}`));
+}
+function reportRemoved(plan) {
+	const removed = plan.files.filter((file) => file.category === "removed");
+	if (removed.length === 0) return;
+	log.message(`Removed by templates (${removed.length}):`);
+	for (const entry of removed) log.message(pc.dim(`  - ${entry.path}${entry.reason ? ` — ${entry.reason}` : ""}`));
+}
+function renderPlan(plan) {
+	log.info(pc.dim(`Path: ${plan.projectDir}`));
+	log.info(pc.dim(plan.hasBaseline ? `Baseline: bts.lock.json${plan.baselineCreatedAt ? ` (recorded ${plan.baselineCreatedAt})` : ""}` : "Baseline: none — run `update --record-baseline` to enable safe auto-patching"));
+	log.message("");
+	reportGroup("Template drift (safe to patch)", "~", plan.drift);
+	reportGroup("New files from templates", "+", plan.newFiles);
+	reportGroup("Locally edited (kept as-is)", "*", plan.userEdited);
+	reportGroup("Conflicts (template + local both changed)", "!", plan.conflicts);
+	reportManual(plan.manual);
+	reportRemoved(plan);
+	log.message("");
+	log.message(pc.dim(`${plan.unchanged.length} up to date · ${plan.drift.length} drift · ${plan.newFiles.length} new · ${plan.userEdited.length} local · ${plan.conflicts.length} conflict · ${plan.manual.length} manual`));
+}
+function toJsonPlan(plan) {
+	return {
+		projectDir: plan.projectDir,
+		hasBaseline: plan.hasBaseline,
+		baselineCreatedAt: plan.baselineCreatedAt,
+		summary: {
+			unchanged: plan.unchanged.length,
+			drift: plan.drift.length,
+			newFiles: plan.newFiles.length,
+			userEdited: plan.userEdited.length,
+			conflicts: plan.conflicts.length,
+			manual: plan.manual.length,
+			removed: plan.removed.length
+		},
+		drift: plan.drift,
+		newFiles: plan.newFiles,
+		userEdited: plan.userEdited,
+		conflicts: plan.conflicts,
+		manual: plan.manual,
+		removed: plan.removed,
+		actionable: plan.actionable
+	};
+}
+async function updateCommand(input) {
+	const projectDir = path.resolve(input.projectDir || process.cwd());
+	const json = input.json ?? false;
+	const apply = input.apply ?? false;
+	const check = input.check ?? false;
+	const dryRun = input.dryRun ?? false;
+	const recordBaseline = input.recordBaseline ?? false;
+	if (dryRun && apply) return failUpdate(projectDir, "`--dry-run` cannot be combined with `--apply`.", json);
+	if (dryRun && recordBaseline) return failUpdate(projectDir, "`--dry-run` cannot be combined with `--record-baseline`.", json);
+	if (check && apply) return failUpdate(projectDir, "`--check` cannot be combined with `--apply`.", json);
+	if (check && recordBaseline) return failUpdate(projectDir, "`--check` cannot be combined with `--record-baseline`.", json);
+	if (apply && recordBaseline) return failUpdate(projectDir, "`--apply` cannot be combined with `--record-baseline`.", json);
+	if (!await readBtsConfig(projectDir)) {
+		const message = `No Better Fullstack project found in ${projectDir}. Make sure bts.jsonc exists.`;
+		if (json) {
+			console.log(JSON.stringify({
+				projectDir,
+				ok: false,
+				error: message
+			}, null, 2));
+			process.exit(1);
+		}
+		handleError(message);
+	}
+	if (recordBaseline) {
+		const manifest = await recordScaffoldManifest(projectDir);
+		if (json) {
+			console.log(JSON.stringify({
+				projectDir,
+				ok: manifest !== null,
+				recordedBaseline: manifest !== null,
+				files: manifest ? Object.keys(manifest.hashes).length : 0
+			}, null, 2));
+			if (!manifest) process.exit(1);
+			return;
+		}
+		renderTitle();
+		intro(pc.magenta("Record scaffold baseline"));
+		if (!manifest) handleError(`Failed to record a baseline for ${projectDir}.`);
+		log.success(pc.green(`Recorded bts.lock.json with ${formatCount(Object.keys(manifest.hashes).length, "file")}.`));
+		outro(pc.magenta("Baseline recorded. Future `bfs update` runs can now auto-patch template drift."));
+		return;
+	}
+	let plan;
+	let applied;
+	if (apply) {
+		const result = await applyScaffoldUpgrade(projectDir);
+		if (!result.success) return failUpdate(projectDir, result.error, json);
+		plan = result;
+		applied = result.applied;
+	} else {
+		const result = await planScaffoldUpgrade(projectDir);
+		if (!result.success) return failUpdate(projectDir, result.error, json);
+		plan = result;
+		applied = void 0;
+	}
+	if (json) {
+		console.log(JSON.stringify({
+			...toJsonPlan(plan),
+			ok: true,
+			mode: apply ? "apply" : check ? "check" : "dry-run",
+			applied
+		}, null, 2));
+		if (check && plan.actionable.length > 0) process.exit(1);
+		return;
+	}
+	renderTitle();
+	intro(pc.magenta(apply ? `Updating ${pc.cyan(path.basename(projectDir))} to current templates` : `Update plan for ${pc.cyan(path.basename(projectDir))}`));
+	renderPlan(plan);
+	log.message("");
+	if (applied) {
+		if (applied.patched.length + applied.added.length === 0) log.success(pc.green("Already up to date. No template-drift patches to apply."));
+		else log.success(pc.green(`Applied ${formatCount(applied.patched.length, "patch")} and added ${formatCount(applied.added.length, "file")}.`));
+		const leftover = plan.conflicts.length + plan.manual.length;
+		if (leftover > 0) log.warn(pc.yellow(`${formatCount(leftover, "file")} still need manual review (conflicts + post-processed files).`));
+		outro(pc.magenta("Update complete."));
+		return;
+	}
+	if (plan.actionable.length === 0) log.success(pc.green("Up to date with the current templates."));
+	else log.info(pc.cyan(`Run \`bfs update --apply\` to patch ${formatCount(plan.drift.length, "drift file")} and add ${formatCount(plan.newFiles.length, "new file")}.`));
+	outro(pc.magenta(apply ? "Update complete." : "Dry run — no files were written."));
+	if (check && plan.actionable.length > 0) process.exit(1);
+}
+
+//#endregion
+export { updateCommand };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-better-fullstack",
-  "version": "2.1.4",
+  "version": "2.1.6",
   "description": "Scaffold production-ready fullstack apps in seconds. Pick your stack from 425 options — the CLI wires everything together.",
   "keywords": [
     "algolia",
@@ -128,8 +128,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@better-fullstack/template-generator": "^2.1.4",
-    "@better-fullstack/types": "^2.1.4",
+    "@better-fullstack/template-generator": "^2.1.6",
+    "@better-fullstack/types": "^2.1.6",
     "@clack/core": "^0.5.0",
     "@clack/prompts": "^1.6.0",
     "@orpc/server": "^1.14.6",

package/dist/addons-setup-DyMm42a5.mjs

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-import "./errors-Cyol8zbN.mjs";
-import { t as setupAddons } from "./addons-setup-CyrP1IV-.mjs";
-
-export { setupAddons };

package/dist/mcp-CsW3i66c.mjs

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-import "./errors-Cyol8zbN.mjs";
-import "./file-formatter-B3dsev2l.mjs";
-import { i as startMcpServer, n as MCP_STACK_UPDATE_SCHEMA, r as getMcpGraphPreview, t as MCP_PLAN_CREATE_SCHEMA } from "./mcp-entry.mjs";
-
-export { startMcpServer };

package/dist/run-_cf_sFwM.mjs

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import "./errors-Cyol8zbN.mjs";
-import { a as createBtsCli, c as history, d as telemetry, i as create, l as router, n as builder, o as docs, r as check, s as doctor, t as add, u as sponsors } from "./run-BYse4yJy.mjs";
-import "./render-title-zvyKC1ej.mjs";
-import "./addons-setup-CyrP1IV-.mjs";
-import "./file-formatter-B3dsev2l.mjs";
-import "./install-dependencies-CgNh-aOy.mjs";
-import "./generated-checks-C8hn9w2i.mjs";
-
-export { createBtsCli };