@wolfstar/create-http-framework 2.2.0-next-20260831123711 → 2.2.0

package/dist/index.js

@@ -418,6 +418,39 @@ function writeProjectFiles(targetDir, ctx) {
 const templateDir = join(fileURLToPath(import.meta.url), "../..", "template");
 const baseDir = join(templateDir, "base");
 const featuresDir = join(templateDir, "features");
+/**
+* Records the `TemplateContext` used for the last successful {@link processTemplate} run. Reruns
+* use it to compare a stale file against an *exact* rendering of whatever produced it, so a
+* genuinely pristine file is recognized regardless of what `--port`/name/`--language` changed this
+* run, while a hand-edit — however small, even a single digit inside what would otherwise be a
+* `{{port}}` slot — still fails the comparison and is preserved. See {@link removeStaleGeneratedFiles}
+* for the (deliberately less precise) fallback used when this manifest is missing.
+*/
+const manifestFilename = ".create-http-framework.json";
+function readManifest(outputDir) {
+	try {
+		return JSON.parse(readFileSync(join(outputDir, manifestFilename), "utf-8"));
+	} catch {
+		return;
+	}
+}
+function writeManifest(outputDir, context) {
+	writeFile(join(outputDir, manifestFilename), `${JSON.stringify(context, null, "	")}\n`);
+}
+/**
+* `@wolfstar/i18next-type-generator` writes this file when the CLI runs it after `processTemplate`
+* (see `index.ts`). It isn't part of the Handlebars template set — its content is derived from the
+* project's own locale keys, not from a static source file — so {@link removeStaleGeneratedFiles}
+* has no candidate to diff it against and would never touch it, manifest or not. Delete it directly
+* whenever i18n is disabled: it's pure `generate:i18n` output, never meant to be hand-edited.
+*/
+function removeI18nDeclaration(outputDir) {
+	const target = join(outputDir, "src", "@types", "i18next.d.ts");
+	if (!existsSync(target)) return;
+	rmSync(target);
+	const typesDir = dirname(target);
+	if (existsSync(typesDir) && readdirSync(typesDir).length === 0) rmSync(typesDir, { recursive: true });
+}
 function walkDir(dir) {
 	const entries = readdirSync(dir);
 	const files = [];
@@ -463,6 +496,33 @@ function renderSource(absoluteSource, context) {
 	const rawContent = readFileSync(absoluteSource, "utf-8");
 	return absoluteSource.endsWith(".hbs") ? Handlebars.compile(rawContent)(context) : rawContent;
 }
+function escapeRegExp(text) {
+	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** True unless `rawSource` uses a Handlebars block helper (`{{#if}}`, `{{#each}}`, …) — see {@link buildStaleFileMatcher}. */
+function isSimpleInterpolationOnly(rawSource) {
+	return !/\{\{[#/]/.test(rawSource);
+}
+/**
+* Builds a *legacy-migration-only* fallback matcher for what `absoluteSource` could have rendered
+* to, treating each `{{variable}}` interpolation as an unrestricted wildcard. This is deliberately
+* imprecise — a hand-edit confined to what would otherwise be a `{{port}}` slot (e.g. the user
+* changing just the fallback port number) is indistinguishable from a stale-but-pristine file and
+* gets deleted. It only runs when there's no manifest to compare against exactly (see
+* {@link removeStaleGeneratedFiles}), which is limited to projects generated before the manifest
+* existed — every run after this one writes a manifest, closing the gap for good.
+*
+* `null` for files with block helpers (`{{#if}}`, …), which can't be turned into a simple wildcard
+* pattern this way; none currently end up in "stale candidate" position, but this keeps the caller's
+* exact-render fallback available if that changes.
+*/
+function buildStaleFileMatcher(absoluteSource) {
+	const rawContent = readFileSync(absoluteSource, "utf-8");
+	if (!absoluteSource.endsWith(".hbs")) return new RegExp(`^${escapeRegExp(rawContent)}$`);
+	if (!isSimpleInterpolationOnly(rawContent)) return null;
+	const literalChunks = rawContent.split(/\{\{\s*[\w.]+\s*\}\}/g).map(escapeRegExp);
+	return new RegExp(`^${literalChunks.join("[\\s\\S]*?")}$`);
+}
 /**
 * Maps every output-relative path `root` could ever produce — for either language — to the source
 * file(s) that render it. Unlike {@link collectOutputPaths} this ignores `context.language`, so it
@@ -488,11 +548,20 @@ function collectCandidateSources(root) {
 * dropped from `package.json` (e.g. `@wolfstar/plugin-i18next`), breaking install/build.
 *
 * Deletes any known generator output path that isn't produced by `base/` or an active feature this
-* run, but only when the file on disk still matches byte-for-byte what the generator would have
-* written for it — i.e. it wasn't hand-edited since. Hand-edited files are left in place (and their
-* paths returned) so the caller can warn instead of silently discarding user work.
+* run, but only when the file on disk still matches what the generator would have written for it —
+* i.e. it wasn't hand-edited since. Hand-edited files are left in place (and their paths returned)
+* so the caller can warn instead of silently discarding user work.
+*
+* When a manifest is present, the comparison is an *exact* render of the candidate against the
+* context recorded there — the one that actually produced the file — so it's precise even after
+* `--port`/name/`--language` changed this run, and still catches a hand-edit as small as one digit.
+* When it's missing (a project generated before the manifest existed), falls back to
+* {@link buildStaleFileMatcher}'s wildcard comparison: less precise (a hand-edit confined to a
+* `{{variable}}` slot won't be caught), but still correctly cleans up the common case instead of
+* leaving a dangling import forever. That gap closes after this run, which always writes a manifest.
 */
 function removeStaleGeneratedFiles(outputDir, context) {
+	const manifestContext = readManifest(outputDir);
 	const keepPaths = collectOutputPaths(baseDir, context.language);
 	for (const feature of resolveFeatureDirs(context)) for (const path of collectOutputPaths(join(featuresDir, feature), context.language)) keepPaths.add(path);
 	const candidates = collectCandidateSources(baseDir);
@@ -507,7 +576,10 @@ function removeStaleGeneratedFiles(outputDir, context) {
 		const target = join(outputDir, path);
 		if (!existsSync(target)) continue;
 		const actual = readFileSync(target, "utf-8");
-		if (sources.some((source) => renderSource(source, context) === actual)) rmSync(target);
+		if (manifestContext ? sources.some((source) => renderSource(source, manifestContext) === actual) : sources.some((source) => {
+			const matcher = buildStaleFileMatcher(source);
+			return matcher ? matcher.test(actual) : renderSource(source, context) === actual;
+		})) rmSync(target);
 		else preserved.push(path);
 	}
 	return preserved;
@@ -541,8 +613,10 @@ function processDir(root, outputDir, context) {
 */
 async function processTemplate(outputDir, context) {
 	const preserved = removeStaleGeneratedFiles(outputDir, context);
+	if (!context.i18n) removeI18nDeclaration(outputDir);
 	processDir(baseDir, outputDir, context);
 	for (const feature of resolveFeatureDirs(context)) processDir(join(featuresDir, feature), outputDir, context);
+	writeManifest(outputDir, context);
 	return preserved;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wolfstar/create-http-framework",
-  "version": "2.2.0-next-20260831123711",
+  "version": "2.2.0",
   "description": "Create a new WolfStar HTTP Framework bot project",
   "keywords": [
     "cli",

package/template/base/.gitignore.hbs

@@ -2,3 +2,4 @@ node_modules/
 dist/
 .env
 *.js.map
+.create-http-framework.json