create-landing-app 0.1.0

package/dist/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { intro, outro, cancel } from "@clack/prompts";
+import { bold, cyan } from "kolorist";
+import { runPrompts } from "./prompts.js";
+import { scaffold } from "./scaffold.js";
+import { install } from "./install.js";
+import path from "path";
+async function main() {
+    console.log();
+    intro(`${bold(cyan("create-landing-app"))} — Next.js landing page scaffold`);
+    const config = await runPrompts();
+    if (!config) {
+        cancel("Cancelled.");
+        process.exit(0);
+    }
+    const targetDir = path.resolve(process.cwd(), config.projectName);
+    await scaffold(config, targetDir);
+    await install(config.packageManager, targetDir);
+    outro(`Done! cd ${config.projectName} && ${config.packageManager} dev`);
+}
+main().catch((e) => { console.error(e); process.exit(1); });

package/dist/install.js

@@ -0,0 +1,18 @@
+import { execa } from "execa";
+import { spinner } from "@clack/prompts";
+export async function install(pm, cwd) {
+    const s = spinner();
+    s.start(`Installing dependencies with ${pm}...`);
+    try {
+        if (pm === "bun")
+            await execa("bun", ["install"], { cwd });
+        else if (pm === "pnpm")
+            await execa("pnpm", ["install"], { cwd });
+        else
+            await execa("yarn", [], { cwd });
+        s.stop("Dependencies installed.");
+    }
+    catch {
+        s.stop("Install failed. Run install manually.");
+    }
+}

package/dist/prompts.js

@@ -0,0 +1,62 @@
+import { text, select, confirm, isCancel } from "@clack/prompts";
+export async function runPrompts() {
+    const projectName = await text({
+        message: "Project name?",
+        placeholder: "my-landing",
+        validate: (v) => (v.trim().length === 0 ? "Required" : undefined),
+    });
+    if (isCancel(projectName))
+        return null;
+    const packageManager = await select({
+        message: "Package manager?",
+        options: [
+            { value: "bun", label: "bun" },
+            { value: "pnpm", label: "pnpm" },
+            { value: "yarn", label: "yarn" },
+        ],
+    });
+    if (isCancel(packageManager))
+        return null;
+    const i18n = await select({
+        message: "i18n / Translation?",
+        options: [
+            { value: "none", label: "None" },
+            { value: "dict", label: "Dictionary-based (no extra deps)" },
+        ],
+    });
+    if (isCancel(i18n))
+        return null;
+    const stateManagement = await select({
+        message: "State management?",
+        options: [
+            { value: "none", label: "None (recommended for simple sites)" },
+            { value: "zustand", label: "Zustand" },
+        ],
+    });
+    if (isCancel(stateManagement))
+        return null;
+    const dataFetching = await select({
+        message: "Data fetching?",
+        options: [
+            { value: "none", label: "None" },
+            { value: "tanstack-query", label: "TanStack Query" },
+        ],
+    });
+    if (isCancel(dataFetching))
+        return null;
+    const blog = await confirm({ message: "Include Blog section?" });
+    if (isCancel(blog))
+        return null;
+    const docker = await confirm({ message: "Include Docker setup? (for VPS deploy)" });
+    if (isCancel(docker))
+        return null;
+    return {
+        projectName: String(projectName).trim(),
+        packageManager: packageManager,
+        i18n: i18n,
+        stateManagement: stateManagement,
+        dataFetching: dataFetching,
+        blog: Boolean(blog),
+        docker: Boolean(docker),
+    };
+}

package/dist/scaffold.js

@@ -0,0 +1,159 @@
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { copyDir } from "./utils/copy-dir.js";
+import { mergeJson } from "./utils/merge-json.js";
+// Resolve templates root relative to this file (ESM-compatible)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// When installed from npm, templates are bundled at ../templates (prepublishOnly copies them).
+// In local monorepo dev, templates live at ../../../templates.
+const _npmTemplates = path.resolve(__dirname, "../templates/nextjs");
+const _devTemplates = path.resolve(__dirname, "../../../templates/nextjs");
+const TEMPLATES_ROOT = fs.existsSync(_npmTemplates) ? _npmTemplates : _devTemplates;
+export async function scaffold(config, targetDir) {
+    fs.mkdirSync(targetDir, { recursive: true });
+    // 1. Copy base template
+    await copyDir(path.join(TEMPLATES_ROOT, "base"), targetDir);
+    // 2. Build list of optional features to apply
+    // ORDERING MATTERS: i18n-dict must run before any section inject that targets
+    // app/[lang]/page.tsx — that file is created by i18n-dict, so sections injecting
+    // into it must come after. Same logic applies to zustand/tanstack-query providers.
+    const optionals = [];
+    if (config.i18n === "dict")
+        optionals.push("i18n-dict");
+    if (config.stateManagement === "zustand")
+        optionals.push("zustand");
+    if (config.dataFetching === "tanstack-query")
+        optionals.push("tanstack-query");
+    // Sections run after i18n/state/data so their inject targets already exist
+    optionals.push("sections/about");
+    if (config.blog)
+        optionals.push("sections/blog");
+    if (config.docker)
+        optionals.push("docker");
+    // 3. Apply each optional feature (files + inject markers)
+    for (const opt of optionals) {
+        const optDir = path.join(TEMPLATES_ROOT, "optional", opt);
+        if (fs.existsSync(optDir)) {
+            await mergeOptional(optDir, targetDir);
+        }
+    }
+    // 4. Apply Pila theme by default
+    applyTheme("pila", targetDir);
+    // 5. Replace __TOKEN__ placeholders in all text files
+    replaceTokensInDir(targetDir, {
+        __PROJECT_NAME__: config.projectName,
+        __PACKAGE_MANAGER__: config.packageManager,
+        __THEME__: "pila",
+    });
+    // 6. Remove leftover marker comments from all text files
+    cleanupMarkersInDir(targetDir);
+    // 7. Merge package.json fragments from optional features
+    mergePackageJsonFragments(targetDir, optionals);
+    // 8. Make husky scripts executable
+    setupHusky(targetDir);
+}
+async function mergeOptional(optDir, targetDir) {
+    // Copy new files from optional/files/ — optional files override base
+    const filesDir = path.join(optDir, "files");
+    if (fs.existsSync(filesDir)) {
+        await copyDir(filesDir, targetDir, true);
+    }
+    // Inject code into base files via markers
+    const injectDir = path.join(optDir, "inject");
+    if (fs.existsSync(injectDir)) {
+        for (const injectFile of fs.readdirSync(injectDir)) {
+            const injectContent = fs.readFileSync(path.join(injectDir, injectFile), "utf8");
+            // Filename encodes path: "components__providers.tsx" → "components/providers.tsx"
+            const targetFile = path.join(targetDir, injectFile.replace(/__/g, "/"));
+            if (fs.existsSync(targetFile)) {
+                injectIntoMarkers(targetFile, injectContent);
+            }
+        }
+    }
+}
+function injectIntoMarkers(filePath, injectContent) {
+    // Format: "MARKER:__MARKER_NAME__\n<code>\n---\nMARKER:...\n<code>"
+    let fileContent = fs.readFileSync(filePath, "utf8");
+    const blocks = injectContent.split(/^---$/m);
+    for (const block of blocks) {
+        const markerMatch = block.match(/^MARKER:(\S+)\n([\s\S]*)/m);
+        if (!markerMatch)
+            continue;
+        const [, marker, code] = markerMatch;
+        // Insert before marker, keeping marker intact so subsequent sections can inject too
+        fileContent = fileContent
+            .replace(`{/* ${marker} */}`, `${code.trim()}\n{/* ${marker} */}`)
+            .replace(`// ${marker}`, `${code.trim()}\n// ${marker}`);
+    }
+    fs.writeFileSync(filePath, fileContent);
+}
+function cleanupMarkersInDir(dir) {
+    // Remove residual marker comment lines: "// __MARKER__" and "{/* __MARKER__ */}"
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory() && entry.name !== "node_modules") {
+            cleanupMarkersInDir(fullPath);
+        }
+        else if (entry.isFile() && /\.(ts|tsx)$/.test(entry.name)) {
+            let content = fs.readFileSync(fullPath, "utf8");
+            const cleaned = content
+                .replace(/^\s*\/\/ __[A-Z_]+__\s*\n/gm, "")
+                .replace(/^\s*\{\/\* __[A-Z_]+__ \*\/\}\s*\n/gm, "");
+            if (cleaned !== content)
+                fs.writeFileSync(fullPath, cleaned);
+        }
+    }
+}
+function applyTheme(theme, targetDir) {
+    const themeFile = path.join(TEMPLATES_ROOT, "themes", `${theme}.css`);
+    const targetTheme = path.join(targetDir, "styles", "theme.css");
+    if (fs.existsSync(themeFile)) {
+        fs.mkdirSync(path.dirname(targetTheme), { recursive: true });
+        fs.copyFileSync(themeFile, targetTheme);
+    }
+}
+function replaceTokensInDir(dir, tokens) {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory() && entry.name !== "node_modules") {
+            replaceTokensInDir(fullPath, tokens);
+        }
+        else if (entry.isFile() && /\.(ts|tsx|json|css|md|env|sh|yml|yaml)$/.test(entry.name)) {
+            let content = fs.readFileSync(fullPath, "utf8");
+            for (const [token, value] of Object.entries(tokens)) {
+                content = content.replaceAll(token, value);
+            }
+            fs.writeFileSync(fullPath, content);
+        }
+    }
+}
+function mergePackageJsonFragments(targetDir, optionals) {
+    const basePkgPath = path.join(targetDir, "package.json");
+    let basePkg = JSON.parse(fs.readFileSync(basePkgPath, "utf8"));
+    for (const opt of optionals) {
+        const fragPath = path.join(TEMPLATES_ROOT, "optional", opt, "pkg.json");
+        if (fs.existsSync(fragPath)) {
+            const fragment = JSON.parse(fs.readFileSync(fragPath, "utf8"));
+            basePkg = mergeJson(basePkg, fragment);
+        }
+    }
+    fs.writeFileSync(basePkgPath, JSON.stringify(basePkg, null, 2));
+}
+function setupHusky(targetDir) {
+    // Make husky hook scripts and shell scripts executable before install runs
+    const scripts = [
+        ".husky/pre-commit",
+        ".husky/commit-msg",
+        ".husky/pre-push",
+        "scripts/build-and-scan.sh",
+        "scripts/lighthouse-check.sh",
+    ];
+    for (const script of scripts) {
+        const fullPath = path.join(targetDir, script);
+        if (fs.existsSync(fullPath)) {
+            fs.chmodSync(fullPath, "755");
+        }
+    }
+}

package/dist/utils/__tests__/merge-json.test.js

@@ -0,0 +1,144 @@
+import { mergeJson } from '../merge-json';
+describe('mergeJson', () => {
+    describe('plain merge', () => {
+        it('should merge simple objects', () => {
+            const a = { x: 1, y: 2 };
+            const b = { z: 3 };
+            expect(mergeJson(a, b)).toEqual({ x: 1, y: 2, z: 3 });
+        });
+        it('should override scalar values in a with values from b', () => {
+            const a = { x: 1, y: 2 };
+            const b = { x: 10 };
+            expect(mergeJson(a, b)).toEqual({ x: 10, y: 2 });
+        });
+        it('should handle empty objects', () => {
+            expect(mergeJson({}, {})).toEqual({});
+            expect(mergeJson({ a: 1 }, {})).toEqual({ a: 1 });
+            expect(mergeJson({}, { b: 2 })).toEqual({ b: 2 });
+        });
+    });
+    describe('nested object merge', () => {
+        it('should deeply merge nested objects', () => {
+            const a = { config: { debug: true, port: 3000 } };
+            const b = { config: { timeout: 5000 } };
+            expect(mergeJson(a, b)).toEqual({
+                config: { debug: true, port: 3000, timeout: 5000 },
+            });
+        });
+        it('should override scalar values in nested objects', () => {
+            const a = { config: { debug: true, port: 3000 } };
+            const b = { config: { debug: false } };
+            expect(mergeJson(a, b)).toEqual({
+                config: { debug: false, port: 3000 },
+            });
+        });
+        it('should handle multiple levels of nesting', () => {
+            const a = {
+                app: { server: { port: 3000, host: 'localhost' }, name: 'app1' },
+            };
+            const b = {
+                app: { server: { timeout: 5000 }, version: '1.0.0' },
+            };
+            expect(mergeJson(a, b)).toEqual({
+                app: {
+                    server: { port: 3000, host: 'localhost', timeout: 5000 },
+                    name: 'app1',
+                    version: '1.0.0',
+                },
+            });
+        });
+    });
+    describe('array deduplication', () => {
+        it('should concatenate and deduplicate arrays', () => {
+            const a = { items: [1, 2, 3] };
+            const b = { items: [3, 4, 5] };
+            const result = mergeJson(a, b);
+            expect(result.items).toHaveLength(5);
+            expect(result.items).toEqual(expect.arrayContaining([1, 2, 3, 4, 5]));
+        });
+        it('should handle arrays with strings', () => {
+            const a = { tags: ['a', 'b', 'c'] };
+            const b = { tags: ['c', 'd'] };
+            const result = mergeJson(a, b);
+            expect(result.tags).toHaveLength(4);
+            expect(result.tags).toEqual(expect.arrayContaining(['a', 'b', 'c', 'd']));
+        });
+        it('should handle empty arrays', () => {
+            const a = { items: [] };
+            const b = { items: [1, 2] };
+            expect(mergeJson(a, b)).toEqual({ items: [1, 2] });
+            const a2 = { items: [1, 2] };
+            const b2 = { items: [] };
+            const result = mergeJson(a2, b2);
+            expect(result.items).toHaveLength(2);
+            expect(result.items).toEqual(expect.arrayContaining([1, 2]));
+        });
+        it('should deduplicate arrays with duplicate elements', () => {
+            const a = { items: [1, 1, 2] };
+            const b = { items: [2, 3, 3] };
+            const result = mergeJson(a, b);
+            expect(result.items).toHaveLength(3);
+            expect(result.items).toEqual(expect.arrayContaining([1, 2, 3]));
+        });
+    });
+    describe('mixed scenarios', () => {
+        it('should handle arrays and nested objects together', () => {
+            const a = {
+                config: { tags: ['a', 'b'], settings: { debug: true } },
+            };
+            const b = {
+                config: { tags: ['b', 'c'], settings: { verbose: true } },
+            };
+            const result = mergeJson(a, b);
+            const config = result.config;
+            const settings = config.settings;
+            const tags = config.tags;
+            expect(settings).toEqual({ debug: true, verbose: true });
+            expect(tags).toHaveLength(3);
+            expect(tags).toEqual(expect.arrayContaining(['a', 'b', 'c']));
+        });
+        it('should replace arrays when not both are arrays', () => {
+            const a = { data: [1, 2, 3] };
+            const b = { data: 'string value' };
+            expect(mergeJson(a, b)).toEqual({ data: 'string value' });
+        });
+        it('should replace objects when b value is scalar', () => {
+            const a = { config: { x: 1, y: 2 } };
+            const b = { config: 'production' };
+            expect(mergeJson(a, b)).toEqual({ config: 'production' });
+        });
+        it('should preserve original objects (no mutation)', () => {
+            const a = { x: 1, nested: { y: 2 } };
+            const b = { nested: { z: 3 } };
+            const originalA = JSON.stringify(a);
+            mergeJson(a, b);
+            expect(JSON.stringify(a)).toEqual(originalA);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle null and undefined values', () => {
+            const a = { x: null };
+            const b = { x: 'value' };
+            expect(mergeJson(a, b)).toEqual({ x: 'value' });
+        });
+        it('should handle boolean values', () => {
+            const a = { debug: true };
+            const b = { debug: false };
+            expect(mergeJson(a, b)).toEqual({ debug: false });
+        });
+        it('should handle numeric values', () => {
+            const a = { count: 10, ratio: 0.5 };
+            const b = { count: 20 };
+            expect(mergeJson(a, b)).toEqual({ count: 20, ratio: 0.5 });
+        });
+        it('should handle objects with multiple array properties', () => {
+            const a = { deps: ['a', 'b'], devDeps: ['c', 'd'] };
+            const b = { deps: ['b', 'e'], devDeps: ['d', 'f'] };
+            const result = mergeJson(a, b);
+            expect(result.deps).toHaveLength(3);
+            expect(result.deps).toEqual(expect.arrayContaining(['a', 'b', 'e']));
+            expect(result.devDeps).toHaveLength(3);
+            expect(result.devDeps).toEqual(expect.arrayContaining(['c', 'd', 'f']));
+        });
+    });
+});

package/dist/utils/__tests__/replace-tokens.test.js

@@ -0,0 +1,212 @@
+import { replaceTokens } from '../replace-tokens';
+describe('replaceTokens', () => {
+    describe('single token replacement', () => {
+        it('should replace a single token in content', () => {
+            const content = 'Hello __NAME__!';
+            const tokens = { __NAME__: 'World' };
+            expect(replaceTokens(content, tokens)).toBe('Hello World!');
+        });
+        it('should replace token at the start', () => {
+            const content = '__GREETING__ everyone!';
+            const tokens = { __GREETING__: 'Welcome' };
+            expect(replaceTokens(content, tokens)).toBe('Welcome everyone!');
+        });
+        it('should replace token at the end', () => {
+            const content = 'This is __VERSION__';
+            const tokens = { __VERSION__: '1.0.0' };
+            expect(replaceTokens(content, tokens)).toBe('This is 1.0.0');
+        });
+        it('should replace token when it is the entire content', () => {
+            const content = '__TOKEN__';
+            const tokens = { __TOKEN__: 'value' };
+            expect(replaceTokens(content, tokens)).toBe('value');
+        });
+    });
+    describe('multiple token replacement', () => {
+        it('should replace multiple different tokens', () => {
+            const content = 'Project: __PROJECT_NAME__, Version: __VERSION__';
+            const tokens = {
+                __PROJECT_NAME__: 'my-app',
+                __VERSION__: '2.0.0',
+            };
+            expect(replaceTokens(content, tokens)).toBe('Project: my-app, Version: 2.0.0');
+        });
+        it('should replace the same token multiple times', () => {
+            const content = '__PREFIX____SUFFIX__ uses __PREFIX__ everywhere';
+            const tokens = { __PREFIX__: 'app', __SUFFIX__: 'config' };
+            expect(replaceTokens(content, tokens)).toBe('appconfig uses app everywhere');
+        });
+        it('should replace tokens in JSON-like content', () => {
+            const content = '{ "name": "__NAME__", "version": "__VERSION__" }';
+            const tokens = {
+                __NAME__: 'my-package',
+                __VERSION__: '1.0.0',
+            };
+            expect(replaceTokens(content, tokens)).toBe('{ "name": "my-package", "version": "1.0.0" }');
+        });
+        it('should handle many tokens in one call', () => {
+            const content = '__A____B____C____D__';
+            const tokens = {
+                __A__: '1',
+                __B__: '2',
+                __C__: '3',
+                __D__: '4',
+            };
+            expect(replaceTokens(content, tokens)).toBe('1234');
+        });
+    });
+    describe('no tokens (passthrough)', () => {
+        it('should return unchanged content when no tokens present', () => {
+            const content = 'Hello World';
+            const tokens = { __NAME__: 'value' };
+            expect(replaceTokens(content, tokens)).toBe('Hello World');
+        });
+        it('should return unchanged content with empty token map', () => {
+            const content = 'Hello __NAME__!';
+            const tokens = {};
+            expect(replaceTokens(content, tokens)).toBe('Hello __NAME__!');
+        });
+        it('should handle empty content', () => {
+            const content = '';
+            const tokens = { __TOKEN__: 'value' };
+            expect(replaceTokens(content, tokens)).toBe('');
+        });
+    });
+    describe('token in middle of word', () => {
+        it('should replace token even when in middle of word', () => {
+            const content = 'my__APP__name';
+            const tokens = { __APP__: 'project' };
+            expect(replaceTokens(content, tokens)).toBe('myprojectname');
+        });
+        it('should handle hyphenated words with token', () => {
+            const content = 'my-__NAME__-app';
+            const tokens = { __NAME__: 'awesome' };
+            expect(replaceTokens(content, tokens)).toBe('my-awesome-app');
+        });
+        it('should handle underscores adjacent to token', () => {
+            const content = 'func___NAME___function';
+            const tokens = { __NAME__: 'test' };
+            expect(replaceTokens(content, tokens)).toBe('func_test_function');
+        });
+    });
+    describe('special characters and escaping', () => {
+        it('should handle token values with special characters', () => {
+            const content = 'Theme: __THEME__';
+            const tokens = { __THEME__: '@awesome/theme-v2.0' };
+            expect(replaceTokens(content, tokens)).toBe('Theme: @awesome/theme-v2.0');
+        });
+        it('should handle token values with spaces', () => {
+            const content = 'Company: __COMPANY__';
+            const tokens = { __COMPANY__: 'My Awesome Company' };
+            expect(replaceTokens(content, tokens)).toBe('Company: My Awesome Company');
+        });
+        it('should handle token values with newlines', () => {
+            const content = 'Script:\n__SCRIPT__\nEnd';
+            const tokens = { __SCRIPT__: 'echo "hello"\necho "world"' };
+            expect(replaceTokens(content, tokens)).toBe('Script:\necho "hello"\necho "world"\nEnd');
+        });
+        it('should handle token names with numbers', () => {
+            const content = '__TOKEN_1__ and __TOKEN_2__';
+            const tokens = {
+                __TOKEN_1__: 'first',
+                __TOKEN_2__: 'second',
+            };
+            expect(replaceTokens(content, tokens)).toBe('first and second');
+        });
+    });
+    describe('multiline content', () => {
+        it('should replace tokens across multiple lines', () => {
+            const content = `
+Project: __NAME__
+Version: __VERSION__
+Author: __AUTHOR__
+`;
+            const tokens = {
+                __NAME__: 'my-app',
+                __VERSION__: '1.0.0',
+                __AUTHOR__: 'John Doe',
+            };
+            const expected = `
+Project: my-app
+Version: 1.0.0
+Author: John Doe
+`;
+            expect(replaceTokens(content, tokens)).toBe(expected);
+        });
+        it('should replace tokens in code blocks', () => {
+            const content = `
+import __PACKAGE_NAME__ from '@/__PACKAGE_NAME__';
+
+export default __PACKAGE_NAME__;
+`;
+            const tokens = { __PACKAGE_NAME__: 'config' };
+            const expected = `
+import config from '@/config';
+
+export default config;
+`;
+            expect(replaceTokens(content, tokens)).toBe(expected);
+        });
+    });
+    describe('package.json specific use case', () => {
+        it('should replace project name in package.json', () => {
+            const pkgJson = `{
+  "name": "__PROJECT_NAME__",
+  "description": "This is __PROJECT_NAME__"
+}`;
+            const tokens = { __PROJECT_NAME__: 'my-awesome-app' };
+            const expected = `{
+  "name": "my-awesome-app",
+  "description": "This is my-awesome-app"
+}`;
+            expect(replaceTokens(pkgJson, tokens)).toBe(expected);
+        });
+    });
+    describe('env file use case', () => {
+        it('should replace tokens in .env files', () => {
+            const envContent = `
+DATABASE_URL=__DB_URL__
+API_KEY=__API_KEY__
+NEXT_PUBLIC_THEME=__THEME__
+`;
+            const tokens = {
+                __DB_URL__: 'postgresql://localhost/mydb',
+                __API_KEY__: 'secret-key-123',
+                __THEME__: 'dark',
+            };
+            const expected = `
+DATABASE_URL=postgresql://localhost/mydb
+API_KEY=secret-key-123
+NEXT_PUBLIC_THEME=dark
+`;
+            expect(replaceTokens(envContent, tokens)).toBe(expected);
+        });
+    });
+    describe('order independence', () => {
+        it('should produce same result regardless of token order', () => {
+            const content = '__A__ and __B__ and __C__';
+            const tokens = { __A__: '1', __B__: '2', __C__: '3' };
+            const result1 = replaceTokens(content, tokens);
+            expect(result1).toBe('1 and 2 and 3');
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle empty token value', () => {
+            const content = 'Hello __NAME__!';
+            const tokens = { __NAME__: '' };
+            expect(replaceTokens(content, tokens)).toBe('Hello !');
+        });
+        it('should handle token value that looks like a token', () => {
+            const content = 'Value: __TOKEN__';
+            const tokens = { __TOKEN__: '__OTHER_TOKEN__' };
+            expect(replaceTokens(content, tokens)).toBe('Value: __OTHER_TOKEN__');
+        });
+        it('should not double-replace if token value contains the token', () => {
+            const content = '__NAME__';
+            const tokens = { __NAME__: '__NAME__' };
+            // replaceAll will keep replacing, so this will result in the same token infinitely
+            // This is expected behavior - the token replaces with itself
+            expect(replaceTokens(content, tokens)).toBe('__NAME__');
+        });
+    });
+});

package/dist/utils/copy-dir.js

@@ -0,0 +1,22 @@
+import fs from "fs";
+import path from "path";
+// Recursively copy src directory to dest, skipping node_modules.
+// overwrite=false: base template takes priority (default for base copy)
+// overwrite=true: src takes priority (used for optional feature files)
+export async function copyDir(src, dest, overwrite = false) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        if (entry.name === "node_modules")
+            continue;
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDir(srcPath, destPath, overwrite);
+        }
+        else {
+            if (overwrite || !fs.existsSync(destPath)) {
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+}

package/dist/utils/merge-json.js

@@ -0,0 +1,19 @@
+// Deep merge b into a. Arrays are concatenated and deduplicated.
+export function mergeJson(a, b) {
+    const result = { ...a };
+    for (const key of Object.keys(b)) {
+        const aVal = a[key];
+        const bVal = b[key];
+        if (Array.isArray(aVal) && Array.isArray(bVal)) {
+            result[key] = [...new Set([...aVal, ...bVal])];
+        }
+        else if (typeof aVal === "object" && aVal !== null && !Array.isArray(aVal) &&
+            typeof bVal === "object" && bVal !== null && !Array.isArray(bVal)) {
+            result[key] = mergeJson(aVal, bVal);
+        }
+        else {
+            result[key] = bVal;
+        }
+    }
+    return result;
+}

package/dist/utils/replace-tokens.js

@@ -0,0 +1,8 @@
+// Replace all __TOKEN__ occurrences in a string with their values
+export function replaceTokens(content, tokens) {
+    let result = content;
+    for (const [token, value] of Object.entries(tokens)) {
+        result = result.replaceAll(token, value);
+    }
+    return result;
+}