create-template-project 0.1.0 → 0.3.0

package/dist/index.js

@@ -0,0 +1,1221 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import { cancel, intro, outro } from "@clack/prompts";
+import { z } from "zod";
+import path from "node:path";
+import fs from "node:fs/promises";
+import debugLib from "debug";
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import { execa } from "execa";
+//#region src/types.ts
+var TemplateTypeSchema = z.enum([
+	"cli",
+	"web-vanilla",
+	"web-app",
+	"web-fullstack"
+]);
+var PackageManagerSchema = z.enum([
+	"npm",
+	"pnpm",
+	"yarn"
+]);
+var ProjectOptionsSchema = z.object({
+	template: TemplateTypeSchema,
+	projectName: z.string().min(1, "Project name is required"),
+	packageManager: PackageManagerSchema.optional().default("npm"),
+	createGithubRepository: z.boolean().optional().default(false),
+	directory: z.string(),
+	overwrite: z.boolean().optional().default(false),
+	update: z.boolean().optional().default(false),
+	installDependencies: z.boolean().optional().default(false),
+	build: z.boolean().optional().default(false),
+	dev: z.boolean().optional().default(false),
+	open: z.boolean().optional().default(false),
+	progress: z.boolean().optional().default(true)
+});
+//#endregion
+//#region src/utils/file.ts
+var debug$3 = debugLib("create-template-project:utils:file");
+function getTemplateDir(dirname, templateName) {
+	const sourcePath = path.resolve(dirname, "files");
+	const distPath = path.resolve(dirname, "templates", templateName, "files");
+	return existsSync(distPath) ? distPath : sourcePath;
+}
+async function getAllFiles(dirPath, arrayOfFiles = []) {
+	const files = await fs.readdir(dirPath);
+	for (const file of files) {
+		if (file === ".DS_Store") continue;
+		if ((await fs.stat(path.join(dirPath, file))).isDirectory()) arrayOfFiles = await getAllFiles(path.join(dirPath, file), arrayOfFiles);
+		else arrayOfFiles.push(path.join(dirPath, file));
+	}
+	return arrayOfFiles;
+}
+function processContent(filePath, content, opts, addedDeps) {
+	const { projectName, template } = opts;
+	let description = "";
+	switch (template) {
+		case "cli":
+			description = "A modern Node.js CLI application with TypeScript and automated tooling.";
+			break;
+		case "web-vanilla":
+			description = "A standalone web page/application for modern browsers.";
+			break;
+		case "web-fullstack":
+			description = "A full-stack monorepo with an Express server and a React/MUI client.";
+			break;
+		case "web-app":
+			description = "A React application with MUI and TanStack Query.";
+			break;
+	}
+	const pm = opts.packageManager || "npm";
+	let processed = content.replaceAll("{{projectName}}", projectName).replaceAll("{{description}}", description).replaceAll("{{packageManager}}", pm);
+	if (filePath.includes(".github/workflows/node.js.yml")) {
+		let installCommand = "npm ci";
+		let pmSetup = "";
+		if (pm === "pnpm") {
+			installCommand = "pnpm install --frozen-lockfile";
+			pmSetup = "- uses: pnpm/action-setup@v4\n        with:\n          version: 9";
+		} else if (pm === "yarn") installCommand = "yarn install --frozen-lockfile";
+		let playwrightSetup = "";
+		if (template === "web-fullstack" || template === "web-app" || template === "web-vanilla") playwrightSetup = "- name: Install Playwright Browsers & Deps\n        run: npx playwright install --with-deps chromium";
+		processed = processed.replaceAll("{{installCommand}}", installCommand).replaceAll("# [PM_SETUP]", pmSetup).replaceAll("# [PLAYWRIGHT_SETUP]", playwrightSetup);
+		processed = processed.replace(/^\s*# \[PM_SETUP\]\s*\n/m, "");
+		processed = processed.replace(/^\s*# \[PLAYWRIGHT_SETUP\]\s*\n/m, "");
+	}
+	if (template === "web-vanilla" && filePath === "index.html") processed = processed.replace("{{scriptSrc}}", "/src/index.ts");
+	if (filePath === "CONTRIBUTING.md" && addedDeps.length > 0) {
+		processed += "\n## Dependencies\n\n";
+		const uniqueDeps = Array.from(new Set(addedDeps.map((d) => JSON.stringify(d)))).map((s) => JSON.parse(s));
+		for (const dep of uniqueDeps) processed += `- **${dep.name}**: ${dep.description}\n`;
+	}
+	if ((template === "web-fullstack" || template === "web-vanilla" || template === "web-app") && filePath === "tsconfig.json") processed = processed.replace(/\/\* Language and Environment \*\/[\s\S]*?\/\* Strict Type-Checking Options \*\//, "/* Language and Environment */\n		\"target\": \"ES2023\" /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */,\n		\"lib\": [\"ES2023\", \"DOM\", \"DOM.Iterable\"] /* Specify a set of bundled library declaration files that describe the target runtime environment. */,\n		\"module\": \"ESNext\" /* Specify what module code is generated. */,\n		\"moduleResolution\": \"bundler\" /* Specify how TypeScript looks up a file from a given module specifier. */,\n		\"esModuleInterop\": true /* Emit additional JavaScript to ease support for importing CommonJS modules. */,\n		\"resolveJsonModule\": true /* Enable importing .json files. */,\n		\"allowImportingTsExtensions\": true /* Allow imports to include TypeScript file extensions. */,\n		\"noEmit\": true /* Disable emitting files from a compilation. */,\n		\"jsx\": \"react-jsx\" /* Specify what JSX code is generated. */,\n\n		/* Strict Type-Checking Options */");
+	if (template === "web-fullstack" && filePath === "tsconfig.json") processed = processed.replace(/"include":\s*\[\s*"src\/\*\*\/\*"\s*\]/, "\"include\": [\"client/src/**/*\", \"server/src/**/*\"]");
+	return processed;
+}
+function mergePackageJson(target, source) {
+	if (source.scripts) target.scripts = {
+		...target.scripts,
+		...source.scripts
+	};
+	if (source.dependencies) target.dependencies = {
+		...target.dependencies,
+		...source.dependencies
+	};
+	if (source.devDependencies) target.devDependencies = {
+		...target.devDependencies,
+		...source.devDependencies
+	};
+	if (source.workspaces) target.workspaces = source.workspaces;
+	if (source.bin) target.bin = source.bin;
+}
+function isSeedFile(filePath) {
+	return [
+		"src/",
+		"client/src/",
+		"server/src/",
+		"backend/src/",
+		"frontend/src/"
+	].some((dir) => filePath.startsWith(dir)) || [
+		"index.html",
+		"App.tsx",
+		"main.tsx",
+		"index.tsx"
+	].some((file) => filePath === file);
+}
+async function mergeFile(filePath, existing, template, log) {
+	debug$3("Merging file: %s", filePath);
+	const tempBase = filePath + ".base.tmp";
+	const tempNew = filePath + ".new.tmp";
+	try {
+		await fs.writeFile(tempNew, template);
+		await fs.writeFile(tempBase, "");
+		try {
+			const stdio = debug$3.enabled ? "inherit" : "pipe";
+			debug$3("Executing: git merge-file %s %s %s", filePath, tempBase, tempNew);
+			await execa("git", [
+				"merge-file",
+				filePath,
+				tempBase,
+				tempNew
+			], {
+				stdio,
+				preferLocal: true
+			});
+			return (await fs.readFile(filePath, "utf8")).trim() !== template.trim() ? "merged" : "updated";
+		} catch (e) {
+			if (e.exitCode === 1) return "conflict";
+			else {
+				debug$3("Git merge-file failed: %O", e);
+				const detail = e.stdout || e.stderr ? `\n\nOutput:\n${e.stdout}\n${e.stderr}` : "";
+				log.error(`Failed to merge ${filePath}: ${e.message}${detail}`);
+				return "error";
+			}
+		}
+	} finally {
+		await fs.rm(tempBase, { force: true });
+		await fs.rm(tempNew, { force: true });
+	}
+}
+//#endregion
+//#region src/templates/base/index.ts
+var __dirname$5 = path.dirname(fileURLToPath(import.meta.url));
+var getBaseTemplate = (_opts) => {
+	return {
+		name: "base",
+		description: "The foundation for all project templates, including common tooling and configuration.",
+		components: [
+			{
+				name: "TypeScript",
+				description: "Mandatory strict mode for type safety."
+			},
+			{
+				name: "oxlint",
+				description: "Ultra-fast Rust-based linter."
+			},
+			{
+				name: "Prettier",
+				description: "Consistent code formatting."
+			},
+			{
+				name: "Vitest",
+				description: "Modern, fast unit testing with coverage."
+			},
+			{
+				name: "Husky",
+				description: "Git hooks for pre-commit linting."
+			},
+			{
+				name: "commitlint",
+				description: "Standardized commit messages."
+			},
+			{
+				name: "conventional-changelog",
+				description: "Automated release notes."
+			},
+			{
+				name: "debug",
+				description: "Structured logging for debugging."
+			},
+			{
+				name: "Zod",
+				description: "TypeScript-first schema validation for runtime type safety."
+			}
+		],
+		dependencies: { zod: "zod" },
+		devDependencies: { "eslint-plugin-regexp": "" },
+		scripts: {},
+		files: [],
+		templateDir: getTemplateDir(__dirname$5, "base")
+	};
+};
+//#endregion
+//#region src/templates/cli/index.ts
+var __dirname$4 = path.dirname(fileURLToPath(import.meta.url));
+var getCliTemplate = (_opts) => {
+	return {
+		name: "cli",
+		description: "A robust Node.js command-line application template.",
+		components: [
+			{
+				name: "commander",
+				description: "The complete solution for Node.js command-line interfaces."
+			},
+			{
+				name: "cli-progress",
+				description: "Easy to use progress-bar for terminal applications."
+			},
+			{
+				name: "Vite",
+				description: "Fast, modern frontend and backend build tool."
+			}
+		],
+		dependencies: {},
+		devDependencies: { vite: "vite" },
+		scripts: {},
+		files: [],
+		templateDir: getTemplateDir(__dirname$4, "cli")
+	};
+};
+//#endregion
+//#region src/templates/web-vanilla/index.ts
+var __dirname$3 = path.dirname(fileURLToPath(import.meta.url));
+var getWebVanillaTemplate = (_opts) => {
+	return {
+		name: "web-vanilla",
+		description: "A modern, standalone web page template with built-in development and testing tooling.",
+		components: [
+			{
+				name: "Vite",
+				description: "Fast frontend build tool and development server."
+			},
+			{
+				name: "Vitest",
+				description: "Modern testing framework with browser support."
+			},
+			{
+				name: "Playwright",
+				description: "Comprehensive end-to-end testing for modern web apps."
+			}
+		],
+		dependencies: {},
+		devDependencies: {
+			vite: "vite",
+			vitest: "vitest",
+			"@vitest/browser": "@vitest/browser",
+			"@vitest/browser-playwright": "@vitest/browser-playwright",
+			playwright: "playwright",
+			"@playwright/test": "@playwright/test"
+		},
+		scripts: {
+			dev: "vite",
+			build: "vite build",
+			preview: "vite preview",
+			test: "vitest run",
+			"test:ui": "vitest",
+			"test:e2e": "playwright test"
+		},
+		files: [],
+		templateDir: getTemplateDir(__dirname$3, "web-vanilla")
+	};
+};
+//#endregion
+//#region src/templates/web-app/index.ts
+var __dirname$2 = path.dirname(fileURLToPath(import.meta.url));
+var getWebAppTemplate = (_opts) => {
+	return {
+		name: "web-app",
+		description: "A React application with MUI and TanStack Query, powered by Vite.",
+		components: [
+			{
+				name: "React",
+				description: "Powerful library for building component-based user interfaces."
+			},
+			{
+				name: "MUI",
+				description: "Rich set of Material Design UI components for React."
+			},
+			{
+				name: "TanStack React Query",
+				description: "Powerful asynchronous state management for React."
+			},
+			{
+				name: "Vite",
+				description: "Next-generation frontend tooling."
+			},
+			{
+				name: "Vitest",
+				description: "Testing framework with cross-browser support."
+			},
+			{
+				name: "Playwright",
+				description: "End-to-end testing for modern web apps."
+			}
+		],
+		dependencies: {
+			react: "react",
+			"react-dom": "react-dom",
+			"@mui/material": "@mui/material",
+			"@mui/icons-material": "@mui/icons-material",
+			"@emotion/react": "@emotion/react",
+			"@emotion/styled": "@emotion/styled",
+			"@tanstack/react-query": "@tanstack/react-query"
+		},
+		devDependencies: {
+			"@types/react": "@types/react",
+			"@types/react-dom": "@types/react-dom",
+			vite: "vite",
+			"@vitejs/plugin-react": "@vitejs/plugin-react",
+			vitest: "vitest",
+			"@vitest/browser": "@vitest/browser",
+			"@vitest/browser-playwright": "@vitest/browser-playwright",
+			playwright: "playwright",
+			"@playwright/test": "@playwright/test",
+			"vitest-browser-react": "vitest-browser-react"
+		},
+		scripts: {
+			dev: "vite",
+			build: "vite build",
+			preview: "vite preview",
+			test: "vitest run",
+			"test:ui": "vitest",
+			"test:e2e": "playwright test",
+			start: "vite preview"
+		},
+		files: [],
+		templateDir: getTemplateDir(__dirname$2, "web-app")
+	};
+};
+//#endregion
+//#region src/templates/web-fullstack/index.ts
+var __dirname$1 = path.dirname(fileURLToPath(import.meta.url));
+var getWebFullstackTemplate = (_opts) => {
+	return {
+		name: "web-fullstack",
+		description: "A comprehensive full-stack monorepo featuring an Express backend with tRPC and a modern React client with MUI.",
+		components: [
+			{
+				name: "React",
+				description: "Powerful library for building component-based user interfaces."
+			},
+			{
+				name: "MUI",
+				description: "Rich set of Material Design UI components for React."
+			},
+			{
+				name: "tRPC",
+				description: "End-to-end typesafe APIs made easy."
+			},
+			{
+				name: "React Query",
+				description: "Powerful asynchronous state management for React."
+			},
+			{
+				name: "Express",
+				description: "Fast, minimalist backend web framework."
+			},
+			{
+				name: "React Router",
+				description: "Declarative routing for the frontend."
+			},
+			{
+				name: "Vite",
+				description: "Fast, modern frontend build tool."
+			}
+		],
+		dependencies: {
+			react: "react",
+			"react-dom": "react-dom",
+			"@mui/material": "@mui/material",
+			"@mui/icons-material": "@mui/icons-material",
+			"@emotion/react": "@emotion/react",
+			"@emotion/styled": "@emotion/styled",
+			express: "express",
+			"@trpc/server": "@trpc/server",
+			"@trpc/client": "@trpc/client",
+			"@trpc/react-query": "@trpc/react-query",
+			"@tanstack/react-query": "@tanstack/react-query",
+			"react-router-dom": "react-router-dom",
+			cors: "cors"
+		},
+		devDependencies: {
+			"@types/react": "@types/react",
+			"@types/react-dom": "@types/react-dom",
+			"@types/express": "@types/express",
+			"@types/cors": "@types/cors",
+			"@playwright/test": "@playwright/test",
+			vite: "vite",
+			"@vitejs/plugin-react": "@vitejs/plugin-react",
+			vitest: "vitest",
+			"@vitest/browser": "@vitest/browser",
+			"@vitest/browser-playwright": "@vitest/browser-playwright",
+			playwright: "playwright",
+			"vitest-browser-react": "vitest-browser-react"
+		},
+		scripts: {
+			build: "npm run build --workspaces",
+			dev: "npm run dev --workspaces",
+			test: "npm run test --workspaces",
+			"test:e2e": "playwright test"
+		},
+		files: [],
+		templateDir: getTemplateDir(__dirname$1, "web-fullstack")
+	};
+};
+//#endregion
+//#region src/generators/info.ts
+var MOCK_OPTS = {
+	template: "cli",
+	projectName: "mock",
+	directory: ".",
+	packageManager: "npm",
+	overwrite: false,
+	update: false,
+	installDependencies: false,
+	build: false,
+	dev: false,
+	open: false,
+	progress: true,
+	createGithubRepository: false
+};
+var getTemplateInfo = (type) => {
+	const opts = {
+		...MOCK_OPTS,
+		template: type
+	};
+	const base = getBaseTemplate(opts);
+	let template;
+	switch (type) {
+		case "cli":
+			template = getCliTemplate(opts);
+			break;
+		case "web-vanilla":
+			template = getWebVanillaTemplate(opts);
+			break;
+		case "web-app":
+			template = getWebAppTemplate(opts);
+			break;
+		case "web-fullstack":
+			template = getWebFullstackTemplate(opts);
+			break;
+	}
+	return {
+		name: template.name,
+		description: template.description,
+		components: [...base.components, ...template.components]
+	};
+};
+var getAllTemplatesInfo = () => {
+	return [
+		"cli",
+		"web-vanilla",
+		"web-app",
+		"web-fullstack"
+	].map((type) => getTemplateInfo(type));
+};
+//#endregion
+//#region src/cli.ts
+var pathExists$1 = (p) => fs.access(p).then(() => true).catch(() => false);
+var debug$2 = debugLib("create-template-project:cli");
+var parseArgs = async () => {
+	debug$2("Parsing CLI arguments: %O", process.argv);
+	const program = new Command();
+	if (process.env.NODE_ENV === "test") program.configureOutput({
+		writeOut: () => {},
+		writeErr: () => {}
+	});
+	program.name("create-template-project").exitOverride().description("Scaffold a new project template").version("0.1.0").option("--debug", "Enable debug output").on("option:debug", () => {
+		process.env["DEBUG"] = "create-template-project:*";
+		debugLib.enable("create-template-project:*");
+	}).addHelpText("after", `
+Commands:
+  create      - Create a new project from a template.
+  update      - Update an existing project from its template.
+  interactive - Start interactive project configuration.
+  info        - Show detailed information about available templates and components.
+
+Templates:
+  cli            - Node.js CLI application with commander and cli-progress.
+  web-vanilla    - Standalone web page (modern HTML/JS).
+  web-app        - React application with MUI and TanStack Query.
+  web-fullstack  - Full-stack monorepo with Express server and React/MUI client.
+`);
+	let commandResult;
+	program.command("info").description("Show detailed information about available templates and their components").option("-t, --template <type>", "Template type (cli, web-vanilla, web-app, web-fullstack)").action((opts) => {
+		debug$2("Executing \"info\" command with options: %O", opts);
+		p.intro("Template Information");
+		if (opts.template) {
+			const typeResult = TemplateTypeSchema.safeParse(opts.template);
+			if (!typeResult.success) {
+				p.log.error(`Invalid template type: ${opts.template}. Must be one of: cli, web-vanilla, web-app, web-fullstack`);
+				process.exit(1);
+			}
+			const info = getTemplateInfo(typeResult.data);
+			p.note([
+				`Description: ${info.description}`,
+				"",
+				"Components:",
+				...info.components.map((c) => `  ● ${c.name}: ${c.description}`)
+			].join("\n"), `Template: ${info.name}`);
+		} else {
+			const allInfo = getAllTemplatesInfo();
+			for (const info of allInfo) p.note([
+				`Description: ${info.description}`,
+				"",
+				"Components:",
+				...info.components.map((c) => `  ● ${c.name}: ${c.description}`)
+			].join("\n"), `Template: ${info.name}`);
+		}
+		p.outro("Use \"create\" to scaffold a new project.");
+		process.exit(0);
+	});
+	program.command("create").description("Create a new project from a template").option("-t, --template <type>", "Template type (cli, web-vanilla, web-app, web-fullstack)").option("-n, --name <name>", "Project name").option("-p, --package-manager <pm>", "Package manager (npm, pnpm, yarn)", "npm").option("--create-github-repository", "Create GitHub project").option("-d, --directory <path>", "Output directory", ".").option("--overwrite", "Overwrite existing directory by removing it first", false).option("--install-dependencies", "Install dependencies after scaffolding", false).option("--build", "Run the CI script (lint, build, test) after scaffolding", false).option("--dev", "Run the dev server after scaffolding", false).option("--open", "Open the browser after scaffolding", false).option("--no-progress", "Do not show progress indicators").action((opts) => {
+		debug$2("Executing \"create\" command with options: %O", opts);
+		commandResult = {
+			...opts,
+			update: false,
+			template: opts.template,
+			projectName: opts.name,
+			packageManager: opts.packageManager,
+			directory: path.resolve(opts.directory),
+			createGithubRepository: !!opts.createGithubRepository,
+			overwrite: !!opts.overwrite,
+			progress: !!opts.progress
+		};
+		debug$2("Processed \"create\" options: %O", commandResult);
+	});
+	program.command("update").description("Update an existing project from its template").addHelpText("after", `
+Details:
+  The update command syncs your project with the latest template changes.
+  It intelligently merges changes into your existing files using 'git merge-file'.
+
+Restrictions & Behavior:
+  - Seed Files: Files in 'src/', 'client/src/', etc., are considered "seed" files and are NEVER overwritten or modified during an update to protect your application logic.
+  - package.json: Dependencies and scripts are merged. Existing versions are preserved unless they are missing.
+  - Merging: For non-seed files, the tool attempts to merge template changes. If a conflict occurs, it will be marked with standard git conflict markers.
+  - Confirmation: The command will always show a summary of proposed changes (ADD, MODIFY) and ask for your confirmation before applying them.
+`).option("-t, --template <type>", "Template type (cli, web-vanilla, web-app, web-fullstack)").option("-n, --name <name>", "Project name").option("-p, --package-manager <pm>", "Package manager (npm, pnpm, yarn)", "npm").option("--create-github-repository", "Create GitHub project").option("-d, --directory <path>", "Output directory", ".").option("--overwrite", "Overwrite existing directory by removing it first", false).option("--install-dependencies", "Install dependencies after scaffolding", false).option("--build", "Run the CI script (lint, build, test) after updating", false).option("--dev", "Run the dev server after scaffolding", false).option("--open", "Open the browser after scaffolding", false).option("--no-progress", "Do not show progress indicators").action((opts) => {
+		debug$2("Executing \"update\" command with options: %O", opts);
+		commandResult = {
+			...opts,
+			update: true,
+			template: opts.template,
+			projectName: opts.name,
+			packageManager: opts.packageManager,
+			directory: path.resolve(opts.directory),
+			createGithubRepository: !!opts.createGithubRepository,
+			overwrite: !!opts.overwrite,
+			progress: !!opts.progress
+		};
+		debug$2("Processed \"update\" options: %O", commandResult);
+	});
+	program.command("interactive").description("Start interactive project configuration").action(async () => {
+		debug$2("Starting interactive configuration");
+		const projectName = await p.text({
+			message: "Project name:",
+			placeholder: "my-app",
+			defaultValue: "my-app",
+			validate: (value) => value && value.length > 0 ? void 0 : "Project name is required"
+		});
+		if (p.isCancel(projectName)) {
+			p.cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		const directory = await p.text({
+			message: "Target directory:",
+			initialValue: "."
+		});
+		if (p.isCancel(directory)) {
+			p.cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		const projectDir = path.resolve(directory, projectName);
+		const exists = await pathExists$1(projectDir);
+		const pkgPath = path.join(projectDir, "package.json");
+		const pkgExists = await pathExists$1(pkgPath);
+		let existingConfig = {};
+		if (pkgExists) try {
+			existingConfig = JSON.parse(await fs.readFile(pkgPath, "utf8"))["create-template-project"] || {};
+			debug$2("Found existing project config: %O", existingConfig);
+		} catch (e) {
+			debug$2("Failed to read existing package.json: %O", e);
+		}
+		let update = false;
+		let overwrite = false;
+		if (exists) {
+			const action = await p.select({
+				message: `Directory "${projectDir}" already exists. What would you like to do?`,
+				options: [
+					{
+						label: "Run an update",
+						value: "update"
+					},
+					{
+						label: "Overwrite existing directory by removing it first",
+						value: "overwrite"
+					},
+					{
+						label: "Cancel",
+						value: "cancel"
+					}
+				]
+			});
+			if (p.isCancel(action) || action === "cancel") {
+				p.cancel("Operation cancelled.");
+				process.exit(0);
+			}
+			if (action === "update") update = true;
+			else if (action === "overwrite") overwrite = true;
+		}
+		let template = existingConfig.template;
+		if (!update || !template) {
+			template = await p.select({
+				message: "Select project template:",
+				initialValue: template || "cli",
+				options: [
+					{
+						label: "CLI Application (Node.js)",
+						value: "cli"
+					},
+					{
+						label: "Web-Vanilla (Standalone)",
+						value: "web-vanilla"
+					},
+					{
+						label: "Web-App (React + MUI)",
+						value: "web-app"
+					},
+					{
+						label: "Web-Fullstack (Express + React Monorepo)",
+						value: "web-fullstack"
+					}
+				]
+			});
+			if (p.isCancel(template)) {
+				p.cancel("Operation cancelled.");
+				process.exit(0);
+			}
+		} else p.log.info(`Using existing template type: ${template}`);
+		let packageManager = "npm";
+		if (!update) {
+			packageManager = await p.select({
+				message: "Select package manager:",
+				initialValue: "npm",
+				options: [
+					{
+						label: "npm",
+						value: "npm"
+					},
+					{
+						label: "pnpm",
+						value: "pnpm"
+					},
+					{
+						label: "yarn",
+						value: "yarn"
+					}
+				]
+			});
+			if (p.isCancel(packageManager)) {
+				p.cancel("Operation cancelled.");
+				process.exit(0);
+			}
+		}
+		const installDependenciesRes = await p.confirm({
+			message: "Should we install dependencies?",
+			initialValue: true
+		});
+		if (p.isCancel(installDependenciesRes)) {
+			p.cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		const installDependencies = installDependenciesRes;
+		let build = false;
+		if (installDependencies) {
+			const res = await p.confirm({
+				message: "Should we run the CI script (lint, build, test)?",
+				initialValue: true
+			});
+			if (p.isCancel(res)) {
+				p.cancel("Operation cancelled.");
+				process.exit(0);
+			}
+			build = res;
+		}
+		const createGithubRepositoryRes = await p.confirm({
+			message: "Should we create a GitHub repository?",
+			initialValue: false
+		});
+		if (p.isCancel(createGithubRepositoryRes)) {
+			p.cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		commandResult = {
+			template,
+			projectName,
+			packageManager,
+			createGithubRepository: createGithubRepositoryRes,
+			directory: path.resolve(directory),
+			update,
+			overwrite,
+			installDependencies,
+			build,
+			dev: false,
+			open: false,
+			progress: true
+		};
+	});
+	if (process.argv.length <= 2) {
+		program.outputHelp();
+		process.exit(0);
+	}
+	try {
+		await program.parseAsync(process.argv);
+	} catch (e) {
+		if (e.code === "commander.helpDisplayed" || e.code === "commander.version" || e.code === "PROCESS_EXIT_0") process.exit(0);
+		if (e.code === "PROCESS_EXIT_1") process.exit(1);
+		p.cancel(e.message);
+		process.exit(1);
+	}
+	if (!commandResult) {
+		debug$2("No command result found");
+		p.cancel("Unknown command or missing options.");
+		process.exit(1);
+	}
+	debug$2("Validating command result with Zod");
+	const validationResult = ProjectOptionsSchema.safeParse(commandResult);
+	if (!validationResult.success) {
+		const errors = validationResult.error.issues.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+		p.cancel(`Invalid options: ${errors}`);
+		process.exit(1);
+	}
+	commandResult = validationResult.data;
+	const projectDir = path.resolve(commandResult.directory, commandResult.projectName);
+	if (await pathExists$1(projectDir) && !commandResult.update && !commandResult.overwrite) {
+		p.cancel(`Directory "${projectDir}" already exists. Use --overwrite to overwrite or "update" command.`);
+		process.exit(1);
+	}
+	if (commandResult.open) {
+		commandResult.dev = true;
+		commandResult.installDependencies = true;
+	}
+	if (commandResult.dev || commandResult.build) commandResult.installDependencies = true;
+	return commandResult;
+};
+//#endregion
+//#region src/generators/project.ts
+var debug$1 = debugLib("create-template-project:generator");
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var getDependencyConfigPath = async () => {
+	const sourcePath = path.resolve(__dirname, "../config/dependencies.json");
+	const distPath = path.resolve(__dirname, "config/dependencies.json");
+	return await pathExists(distPath) ? distPath : sourcePath;
+};
+var pathExists = (p) => fs.access(p).then(() => true).catch(() => false);
+var getLog = (progress) => ({
+	info: (msg) => progress ? p.log.info(msg) : void 0,
+	success: (msg) => progress ? p.log.success(msg) : void 0,
+	warn: (msg) => p.log.warn(msg),
+	error: (msg) => p.log.error(msg)
+});
+var getSpinner = (progress) => {
+	const s = p.spinner();
+	return {
+		start: (msg) => progress ? s.start(msg) : void 0,
+		stop: (msg) => progress ? s.stop(msg) : void 0,
+		message: (msg) => progress ? s.message(msg) : void 0
+	};
+};
+var showNote = (msg, title, progress) => {
+	if (progress !== void 0 && !progress) return;
+	if (title) p.log.success(title);
+	p.note(msg);
+};
+var generateProject = async (opts) => {
+	const { template: type, projectName, directory, update, overwrite, progress } = opts;
+	const isProgress = progress !== false;
+	const log = getLog(isProgress);
+	const spinner = () => getSpinner(isProgress);
+	const projectDir = path.join(directory, projectName);
+	debug$1("Project generation started for: %s", projectName);
+	debug$1("Options: %O", opts);
+	debug$1("Project directory: %s", projectDir);
+	let isUpdate = !!update;
+	if (await pathExists(projectDir)) {
+		if (overwrite) {
+			await fs.rm(projectDir, {
+				recursive: true,
+				force: true
+			});
+			isUpdate = false;
+		} else if (!isUpdate) throw new Error(`Directory "${projectDir}" already exists. Use --overwrite to replace it or --update to update.`);
+	}
+	const templates = [getBaseTemplate(opts)];
+	debug$1("Applying template: base");
+	switch (type) {
+		case "cli":
+			debug$1("Applying template: cli");
+			templates.push(getCliTemplate(opts));
+			break;
+		case "web-vanilla":
+			debug$1("Applying template: web-vanilla");
+			templates.push(getWebVanillaTemplate(opts));
+			break;
+		case "web-app":
+			debug$1("Applying template: web-app");
+			templates.push(getWebAppTemplate(opts));
+			break;
+		case "web-fullstack":
+			debug$1("Applying template: web-fullstack");
+			templates.push(getWebFullstackTemplate(opts));
+			break;
+	}
+	debug$1("Ensuring directory exists: %s", projectDir);
+	await fs.mkdir(projectDir, { recursive: true });
+	debug$1("Loading dependency configuration");
+	const depConfigPath = await getDependencyConfigPath();
+	const depConfig = JSON.parse(await fs.readFile(depConfigPath, "utf8"));
+	const addedDeps = [];
+	const resolveDeps = (deps = {}) => {
+		for (const dep of Object.keys(deps)) {
+			const config = depConfig.dependencies[dep];
+			if (config) {
+				deps[dep] = config.version;
+				addedDeps.push({
+					name: dep,
+					description: config.description
+				});
+			} else {
+				log.warn(`Dependency "${dep}" not found in master configuration. Using empty version.`);
+				debug$1(`Dependency "${dep}" missing in config`);
+			}
+		}
+	};
+	let finalPkg = {
+		name: projectName,
+		version: "0.1.0",
+		type: "module",
+		"create-template-project": { template: type },
+		scripts: {},
+		dependencies: {},
+		devDependencies: {}
+	};
+	const pkgPath = path.join(projectDir, "package.json");
+	if (isUpdate && await pathExists(pkgPath)) {
+		debug$1("Loading existing package.json for update");
+		const existingPkg = JSON.parse(await fs.readFile(pkgPath, "utf8"));
+		finalPkg = {
+			...finalPkg,
+			...existingPkg
+		};
+		finalPkg["create-template-project"] = {
+			...existingPkg["create-template-project"],
+			template: type
+		};
+		finalPkg.scripts = { ...existingPkg.scripts };
+		finalPkg.dependencies = { ...existingPkg.dependencies };
+		finalPkg.devDependencies = { ...existingPkg.devDependencies };
+		debug$1("Loaded existing package.json: %O", finalPkg);
+	}
+	for (const t of templates) {
+		debug$1("Collecting dependencies and scripts from template: %s", t.name);
+		const templateDeps = { ...t.dependencies };
+		const templateDevDeps = { ...t.devDependencies };
+		resolveDeps(templateDeps);
+		resolveDeps(templateDevDeps);
+		Object.assign(finalPkg.scripts, t.scripts);
+		Object.assign(finalPkg.dependencies, templateDeps);
+		Object.assign(finalPkg.devDependencies, templateDevDeps);
+		if (t.workspaces) finalPkg.workspaces = t.workspaces;
+		if (t.templateDir) {
+			const templatePkgPath = path.join(t.templateDir, "package.json");
+			if (await pathExists(templatePkgPath)) {
+				const pkgPart = JSON.parse(await fs.readFile(templatePkgPath, "utf8"));
+				resolveDeps(pkgPart.dependencies);
+				resolveDeps(pkgPart.devDependencies);
+				mergePackageJson(finalPkg, pkgPart);
+			}
+		}
+	}
+	const actions = [];
+	const pendingOperations = [];
+	for (const t of templates) {
+		debug$1("Collecting template files for: %s", t.name);
+		if (t.templateDir) {
+			debug$1("Reading physical files from: %s", t.templateDir);
+			const files = await getAllFiles(t.templateDir);
+			for (const file of files) {
+				let relativePath = path.relative(t.templateDir, file);
+				let targetPath = path.join(projectDir, relativePath);
+				if (isUpdate && isSeedFile(relativePath)) {
+					actions.push({
+						type: "SKIP",
+						path: relativePath
+					});
+					continue;
+				}
+				if (relativePath === "_oxlint.config.ts") {
+					relativePath = "oxlint.config.ts";
+					targetPath = path.join(projectDir, relativePath);
+				}
+				if (relativePath === "package.json") continue;
+				const finalTargetPath = targetPath;
+				const finalRelativePath = relativePath;
+				const content = processContent(relativePath, await fs.readFile(file, "utf8"), opts, addedDeps);
+				const exists = await pathExists(finalTargetPath);
+				if (isUpdate && exists) {
+					const existingContent = await fs.readFile(finalTargetPath, "utf8");
+					if (existingContent.trim() !== content.trim()) {
+						actions.push({
+							type: "MODIFY",
+							path: finalRelativePath
+						});
+						pendingOperations.push(async () => {
+							const result = await mergeFile(finalTargetPath, existingContent, content, log);
+							if (result === "merged") log.info(`ℹ Merged: ${finalRelativePath}`);
+							else if (result === "conflict") log.warn(`⚠ Conflict: ${finalRelativePath}`);
+							else if (result === "updated") log.info(`✔ Updated: ${finalRelativePath}`);
+						});
+					}
+				} else if (!exists) {
+					actions.push({
+						type: "ADD",
+						path: finalRelativePath
+					});
+					pendingOperations.push(async () => {
+						await fs.mkdir(path.dirname(finalTargetPath), { recursive: true });
+						await fs.writeFile(finalTargetPath, content);
+						const normalizedPath = finalRelativePath.split(path.sep).join("/");
+						if (normalizedPath.startsWith(".husky/") && !normalizedPath.endsWith("/")) await fs.chmod(finalTargetPath, 493);
+					});
+				}
+			}
+		}
+		for (const file of t.files) {
+			const targetPath = path.join(projectDir, file.path);
+			if (isUpdate && isSeedFile(file.path)) {
+				actions.push({
+					type: "SKIP",
+					path: file.path
+				});
+				continue;
+			}
+			let content = typeof file.content === "function" ? file.content() : file.content;
+			content = processContent(file.path, content, opts, addedDeps);
+			const exists = await pathExists(targetPath);
+			if (isUpdate && exists) {
+				const existingContent = await fs.readFile(targetPath, "utf8");
+				if (existingContent.trim() !== content.trim()) {
+					actions.push({
+						type: "MODIFY",
+						path: file.path
+					});
+					pendingOperations.push(async () => {
+						const result = await mergeFile(targetPath, existingContent, content, log);
+						if (result === "merged") log.info(`ℹ Merged: ${file.path}`);
+						else if (result === "conflict") log.warn(`⚠ Conflict: ${file.path}`);
+						else if (result === "updated") log.info(`✔ Updated: ${file.path}`);
+					});
+				}
+			} else if (!exists) {
+				actions.push({
+					type: "ADD",
+					path: file.path
+				});
+				pendingOperations.push(async () => {
+					await fs.mkdir(path.dirname(targetPath), { recursive: true });
+					await fs.writeFile(targetPath, content);
+				});
+			}
+		}
+	}
+	const pm = opts.packageManager || "npm";
+	if (pm !== "npm") {
+		for (const [key, value] of Object.entries(finalPkg.scripts)) if (typeof value === "string") finalPkg.scripts[key] = value.replaceAll("npm run ", `${pm} run `);
+	}
+	if (pm === "pnpm" && finalPkg.workspaces) {
+		debug$1("Creating pnpm-workspace.yaml");
+		const workspaceYaml = `packages:\n${finalPkg.workspaces.map((w) => `  - '${w}'`).join("\n")}\n`;
+		pendingOperations.push(async () => {
+			await fs.writeFile(path.join(projectDir, "pnpm-workspace.yaml"), workspaceYaml);
+		});
+		delete finalPkg.workspaces;
+		for (const key of Object.keys(finalPkg.scripts)) {
+			const value = finalPkg.scripts[key];
+			if (typeof value === "string" && value.includes("--workspaces")) finalPkg.scripts[key] = value.replace(" run ", " -r run ").replace(" --workspaces", "");
+		}
+	}
+	if (type === "cli" || type === "web-vanilla" || type === "web-app" || type === "web-fullstack") {
+		const fullPath = path.join(projectDir, "vitest.config.ts");
+		pendingOperations.push(async () => {
+			await fs.rm(fullPath, { force: true });
+		});
+		if (isUpdate && await pathExists(fullPath)) actions.push({
+			type: "DELETE",
+			path: "vitest.config.ts"
+		});
+	}
+	if (isUpdate) actions.push({
+		type: "MODIFY",
+		path: "package.json"
+	});
+	else actions.push({
+		type: "ADD",
+		path: "package.json"
+	});
+	pendingOperations.push(async () => {
+		debug$1("Writing final consolidated package.json to: %s", pkgPath);
+		await fs.writeFile(pkgPath, JSON.stringify(finalPkg, null, "	"));
+	});
+	if (isUpdate && actions.length > 0 && process.env.NODE_ENV !== "test") {
+		const summary = actions.filter((a) => a.type !== "SKIP").map((a) => `  ${a.type.padEnd(8)} ${a.path}`).join("\n");
+		if (summary) {
+			p.note(summary, "Planned changes:");
+			const confirm = await p.confirm({
+				message: "Do you want to apply these changes?",
+				initialValue: true
+			});
+			if (p.isCancel(confirm) || !confirm) {
+				p.cancel("Update cancelled.");
+				process.exit(0);
+			}
+		} else log.info("No changes detected.");
+	}
+	for (const op of pendingOperations) await op();
+	const stdio = debug$1.enabled ? "inherit" : "pipe";
+	if (!await pathExists(path.join(projectDir, ".git"))) {
+		debug$1("Initializing Git repository");
+		try {
+			debug$1("Executing: git init");
+			await execa("git", ["init"], {
+				cwd: projectDir,
+				stdio,
+				preferLocal: true
+			});
+			log.success("Initialized Git repository (git init).");
+		} catch (e) {
+			debug$1("Failed to initialize Git: %O", e);
+			const detail = e.stdout || e.stderr ? `\n\nOutput:\n${e.stdout}\n${e.stderr}` : "";
+			log.error(`Failed to initialize Git: ${e.message}${detail}`);
+		}
+	}
+	if (opts.createGithubRepository && !isUpdate) {
+		debug$1("Creating GitHub repository");
+		try {
+			debug$1("Executing: gh repo create %s --public --source=. --remote=origin", projectName);
+			await execa("gh", [
+				"repo",
+				"create",
+				projectName,
+				"--public",
+				"--source=.",
+				"--remote=origin"
+			], {
+				cwd: projectDir,
+				stdio,
+				preferLocal: true
+			});
+			log.success("Created GitHub repository (gh repo create).");
+		} catch (e) {
+			debug$1("Failed to create GitHub repository: %O", e);
+			const detail = e.stdout || e.stderr ? `\n\nOutput:\n${e.stdout}\n${e.stderr}` : "";
+			log.warn(`Failed to create GitHub repository: ${e.message}${detail}\nEnsure "gh" CLI is installed and authenticated.`);
+		}
+	}
+	if (opts.installDependencies) {
+		debug$1("Installing dependencies using %s", pm);
+		const s = spinner();
+		s.start(`Installing dependencies using ${pm}...`);
+		try {
+			debug$1("Executing: %s install", pm);
+			await execa(pm, ["install"], {
+				cwd: projectDir,
+				stdio,
+				preferLocal: true
+			});
+			s.stop(`\x1b[1G\x1b[2K\x1b[32m◆\x1b[39m  Dependencies installed (${pm} install).`);
+		} catch (e) {
+			debug$1("Failed to install dependencies: %O", e);
+			s.stop("Failed to install dependencies.");
+			const detail = e.stdout || e.stderr ? `\n\nOutput:\n${e.stdout}\n${e.stderr}` : "";
+			log.error(`${e.message}${detail}`);
+			throw new Error(`Failed to install dependencies: ${e.message}${detail}`);
+		}
+	}
+	if (opts.build && finalPkg.scripts.ci) {
+		debug$1("Running CI script");
+		const s = spinner();
+		if (finalPkg.scripts["prettier-write"]) {
+			s.start(`Formatting files with Prettier (${pm} run prettier-write)...`);
+			try {
+				debug$1("Executing: %s run prettier-write", pm);
+				await execa(pm, ["run", "prettier-write"], {
+					cwd: projectDir,
+					stdio,
+					preferLocal: true
+				});
+				s.stop(`\x1b[1G\x1b[2K\x1b[32m◆\x1b[39m  Files formatted (${pm} run prettier-write).`);
+			} catch (e) {
+				debug$1("Failed to format files: %O", e);
+				s.stop("Failed to format files.");
+				const detail = e.stdout || e.stderr ? `\n\nOutput:\n${e.stdout}\n${e.stderr}` : "";
+				log.error(`${e.message}${detail}`);
+			}
+		}
+		s.start(`Running CI script (lint, build, test) (${pm} run ci)...`);
+		try {
+			debug$1("Executing: %s run ci", pm);
+			await execa(pm, ["run", "ci"], {
+				cwd: projectDir,
+				stdio,
+				preferLocal: true
+			});
+			s.stop(`\x1b[1G\x1b[2K\x1b[32m◆\x1b[39m  CI script completed (${pm} run ci).`);
+		} catch (e) {
+			debug$1("Failed to run CI script: %O", e);
+			s.stop("Failed to run CI script.");
+			const detail = e.stdout || e.stderr ? `\n\nOutput:\n${e.stdout}\n${e.stderr}` : "";
+			log.error(`${e.message}${detail}`);
+			throw new Error(`Failed to run CI script: ${e.message}${detail}`);
+		}
+	}
+	log.success(`Project "${projectName}" ${isUpdate ? "updated" : "scaffolded"} successfully in ${projectDir}`);
+	showSummary(opts, pm, isProgress);
+	if (opts.dev && finalPkg.scripts.dev) {
+		log.info("Starting dev server...");
+		if (opts.open) try {
+			debug$1("Executing: %s run dev -- --open", pm);
+			await execa(pm, [
+				"run",
+				"dev",
+				"--",
+				"--open"
+			], {
+				cwd: projectDir,
+				stdio: "inherit",
+				preferLocal: true
+			});
+		} catch (e) {
+			log.error("Dev server failed: " + e);
+		}
+		else try {
+			debug$1("Executing: %s run dev", pm);
+			await execa(pm, ["run", "dev"], {
+				cwd: projectDir,
+				stdio: "inherit",
+				preferLocal: true
+			});
+		} catch (e) {
+			log.error("Dev server failed: " + e);
+		}
+	}
+};
+function showSummary(opts, pm, isProgress) {
+	debug$1("Showing summary for options: %O", opts);
+	const { projectName, template } = opts;
+	const summary = [
+		`Successfully created a new ${template} project named '${projectName}'.`,
+		"",
+		"Available Commands:"
+	];
+	const commands = [
+		`${pm} run dev    - Starts the development server`,
+		`${pm} run build  - Builds the project for production`,
+		`${pm} run test   - Runs the unit test suite (Vitest)`,
+		`${pm} run lint   - Lints and formats the codebase`,
+		`${pm} run ci     - Runs lint, build, and test (used by CI/CD)`
+	];
+	showNote([...summary, ...commands.map((c) => `  ${c}`)].join("\n"), "Project ready", isProgress);
+}
+//#endregion
+//#region src/index.ts
+if (process.argv.includes("--debug")) {
+	process.env["DEBUG"] = "create-template-project:*";
+	debugLib.enable("create-template-project:*");
+}
+var debug = debugLib("create-template-project:main");
+var main = async () => {
+	try {
+		debug("Starting CLI execution");
+		debug("Parsing arguments");
+		const options = await parseArgs();
+		if (!options) return;
+		const isProgress = options.progress !== false;
+		if (isProgress) intro("create-template-project");
+		debug("Arguments parsed: %O", options);
+		debug("Generating project");
+		await generateProject(options);
+		debug("Project generation complete");
+		if (isProgress) outro("Done!");
+	} catch (error) {
+		debug("Execution failed: %O", error);
+		if (error.code === "PROCESS_EXIT_0" || error.code === "commander.helpDisplayed" || error.code === "commander.version") process.exit(0);
+		if (error.code === "PROCESS_EXIT_1") process.exit(1);
+		cancel(error?.message || String(error));
+		process.exit(1);
+	}
+};
+if (import.meta.url.endsWith("src/index.ts") || import.meta.url.endsWith("dist/index.js")) await main();
+//#endregion
+export { main };