create-template-project 0.1.0

package/dist/generators/project.mjs

@@ -0,0 +1,354 @@
+import { getBaseTemplate } from "../templates/base/index.mjs";
+import { getCliTemplate } from "../templates/cli/index.mjs";
+import { getWebpageTemplate } from "../templates/webpage/index.mjs";
+import { getWebappTemplate } from "../templates/webapp/index.mjs";
+import { getFullstackTemplate } from "../templates/fullstack/index.mjs";
+import { getAllFiles, isSeedFile, mergeFile, mergePackageJson, processContent } from "../utils/file.mjs";
+import * as p from "@clack/prompts";
+import path from "node:path";
+import fs from "node:fs/promises";
+import debugLib from "debug";
+import { fileURLToPath } from "node:url";
+import { execa } from "execa";
+//#region src/generators/project.ts
+const debug = debugLib("create-template-project:generator");
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DEPENDENCY_CONFIG_PATH = path.resolve(__dirname, "../config/dependencies.json");
+const pathExists = (p) => fs.access(p).then(() => true).catch(() => false);
+const getLog = (silent) => ({
+	info: (msg) => !silent ? p.log.info(msg) : void 0,
+	success: (msg) => !silent ? p.log.success(msg) : void 0,
+	warn: (msg) => !silent ? p.log.warn(msg) : void 0,
+	error: (msg) => !silent ? p.log.error(msg) : void 0
+});
+const getSpinner = (silent) => {
+	const s = p.spinner();
+	return {
+		start: (msg) => !silent ? s.start(msg) : void 0,
+		stop: (msg) => !silent ? s.stop(msg) : void 0,
+		message: (msg) => !silent ? s.message(msg) : void 0
+	};
+};
+const showNote = (msg, title, silent) => !silent ? p.note(msg, title) : void 0;
+const generateProject = async (opts) => {
+	const { template: type, projectName, directory, update, overwrite, skipBuild, silent } = opts;
+	const isSilent = !!silent;
+	const log = getLog(isSilent);
+	const spinner = () => getSpinner(isSilent);
+	const projectDir = path.join(directory, projectName);
+	debug("Project generation started for: %s", projectName);
+	debug("Options: %O", opts);
+	debug("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("Applying template: base");
+	switch (type) {
+		case "cli":
+			debug("Applying template: cli");
+			templates.push(getCliTemplate(opts));
+			break;
+		case "webpage":
+			debug("Applying template: webpage");
+			templates.push(getWebpageTemplate(opts));
+			break;
+		case "webapp":
+			debug("Applying template: webapp");
+			templates.push(getWebappTemplate(opts));
+			break;
+		case "fullstack":
+			debug("Applying template: fullstack");
+			templates.push(getFullstackTemplate(opts));
+			break;
+	}
+	debug("Ensuring directory exists: %s", projectDir);
+	await fs.mkdir(projectDir, { recursive: true });
+	debug("Loading dependency configuration");
+	const depConfig = JSON.parse(await fs.readFile(DEPENDENCY_CONFIG_PATH, "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(`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("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("Loaded existing package.json: %O", finalPkg);
+	}
+	for (const t of templates) {
+		debug("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.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);
+			}
+		}
+	}
+	for (const t of templates) {
+		debug("Processing template files for: %s", t.name);
+		if (t.templateDir) {
+			debug("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)) {
+					debug("Skipping seed file during update: %s", relativePath);
+					continue;
+				}
+				if (relativePath === "_oxlint.config.ts") {
+					relativePath = "oxlint.config.ts";
+					targetPath = path.join(projectDir, relativePath);
+				}
+				if (relativePath === "package.json") continue;
+				await fs.mkdir(path.dirname(targetPath), { recursive: true });
+				debug("Reading and processing content for: %s", relativePath);
+				let content = await fs.readFile(file, "utf8");
+				content = processContent(relativePath, content, opts, addedDeps);
+				let finalTargetPath = targetPath;
+				if (type === "webpage" && skipBuild && relativePath === "src/index.ts") {
+					debug("Changing target path for webpage index.ts to .js due to skipBuild");
+					finalTargetPath = path.join(projectDir, "src/index.js");
+				}
+				if (isUpdate && await pathExists(finalTargetPath)) {
+					debug("File exists, attempting to update/merge: %s", finalTargetPath);
+					const existingContent = await fs.readFile(finalTargetPath, "utf8");
+					if (existingContent.trim() !== content.trim()) {
+						const result = await mergeFile(finalTargetPath, existingContent, content, log);
+						if (result === "merged") log.info(`ℹ Merged: ${relativePath}`);
+						else if (result === "conflict") log.warn(`⚠ Conflict: ${relativePath}`);
+						else if (result === "updated") log.info(`✔ Updated: ${relativePath}`);
+					} else debug("Content identical, skipping: %s", finalTargetPath);
+				} else {
+					debug("Writing file: %s", finalTargetPath);
+					await fs.writeFile(finalTargetPath, content);
+				}
+			}
+		}
+		for (const file of t.files) {
+			const targetPath = path.join(projectDir, file.path);
+			if (isUpdate && isSeedFile(file.path)) {
+				debug("Skipping programmatic seed file: %s", file.path);
+				continue;
+			}
+			debug("Processing programmatic file: %s", file.path);
+			await fs.mkdir(path.dirname(targetPath), { recursive: true });
+			let content = typeof file.content === "function" ? file.content() : file.content;
+			content = processContent(file.path, content, opts, addedDeps);
+			if (isUpdate && await pathExists(targetPath)) {
+				debug("File exists, attempting to update/merge programmatic file: %s", targetPath);
+				const existingContent = await fs.readFile(targetPath, "utf8");
+				if (existingContent.trim() !== content.trim()) {
+					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 debug("Content identical, skipping programmatic: %s", targetPath);
+			} else {
+				debug("Writing programmatic file: %s", targetPath);
+				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("Creating pnpm-workspace.yaml");
+		const workspaceYaml = `packages:\n${finalPkg.workspaces.map((w) => `  - '${w}'`).join("\n")}\n`;
+		await fs.writeFile(path.join(projectDir, "pnpm-workspace.yaml"), workspaceYaml);
+		delete finalPkg.workspaces;
+		for (const [key, value] of Object.entries(finalPkg.scripts)) if (typeof value === "string" && value.includes("--workspaces")) finalPkg.scripts[key] = value.replace("run ", "-r run ").replace(" --workspaces", "");
+	}
+	if (skipBuild) {
+		debug("Applying skipBuild overrides");
+		delete finalPkg.scripts.build;
+		delete finalPkg.scripts.dev;
+		if (finalPkg.devDependencies) delete finalPkg.devDependencies.tsdown;
+		if (finalPkg.scripts.ci) finalPkg.scripts.ci = finalPkg.scripts.ci.replace(" && npm run build", "").replace(` && ${pm} run build`, "");
+		debug("Removing tsdown configs due to skipBuild");
+		await fs.rm(path.join(projectDir, "tsdown.config.ts"), { force: true });
+		await fs.rm(path.join(projectDir, "client/tsdown.config.ts"), { force: true });
+		await fs.rm(path.join(projectDir, "server/tsdown.config.ts"), { force: true });
+	}
+	debug("Writing final consolidated package.json to: %s", pkgPath);
+	await fs.writeFile(pkgPath, JSON.stringify(finalPkg, null, "	"));
+	if (!await pathExists(path.join(projectDir, ".git"))) {
+		debug("Initializing Git repository");
+		try {
+			await execa("git", ["init"], {
+				cwd: projectDir,
+				preferLocal: true
+			});
+			log.success("Initialized Git repository (git init).");
+		} catch (e) {
+			debug("Failed to initialize Git: %O", e);
+			log.error("Failed to initialize Git: " + e);
+		}
+	}
+	if (opts.createGithubRepository && !isUpdate) {
+		debug("Creating GitHub repository");
+		try {
+			await execa("gh", [
+				"repo",
+				"create",
+				projectName,
+				"--public",
+				"--source=.",
+				"--remote=origin"
+			], {
+				cwd: projectDir,
+				preferLocal: true
+			});
+			log.success("Created GitHub repository (gh repo create).");
+		} catch (e) {
+			debug("Failed to create GitHub repository: %O", e);
+			log.warn("Failed to create GitHub repository. Ensure \"gh\" CLI is installed and authenticated.");
+		}
+	}
+	if (opts.installDependencies) {
+		debug("Installing dependencies using %s", pm);
+		const s = spinner();
+		s.start(`Installing dependencies using ${pm}...`);
+		try {
+			await execa(pm, ["install"], {
+				cwd: projectDir,
+				preferLocal: true
+			});
+			s.stop(`\x1b[1G\x1b[2K\x1b[32m◆\x1b[39m  Dependencies installed (${pm} install).`);
+		} catch (e) {
+			debug("Failed to install dependencies: %O", e);
+			s.stop("Failed to install dependencies.");
+			log.error(String(e));
+			throw new Error("Failed to install dependencies.");
+		}
+	}
+	if (opts.build && finalPkg.scripts.ci) {
+		debug("Running CI script");
+		const s = spinner();
+		if (finalPkg.scripts["prettier-write"]) {
+			s.start(`Formatting files with Prettier (${pm} run prettier-write)...`);
+			try {
+				await execa(pm, ["run", "prettier-write"], {
+					cwd: projectDir,
+					preferLocal: true
+				});
+				s.stop(`\x1b[1G\x1b[2K\x1b[32m◆\x1b[39m  Files formatted (${pm} run prettier-write).`);
+			} catch (e) {
+				debug("Failed to format files: %O", e);
+				s.stop("Failed to format files.");
+			}
+		}
+		s.start(`Running CI script (lint, build, test) (${pm} run ci)...`);
+		try {
+			await execa(pm, ["run", "ci"], {
+				cwd: projectDir,
+				preferLocal: true
+			});
+			s.stop(`\x1b[1G\x1b[2K\x1b[32m◆\x1b[39m  CI script completed (${pm} run ci).`);
+		} catch (e) {
+			debug("Failed to run CI script: %O", e);
+			s.stop("Failed to run CI script.");
+			log.error(String(e));
+			throw new Error("Failed to run CI script.");
+		}
+	}
+	log.info(`Project "${projectName}" ${isUpdate ? "updated" : "scaffolded"} successfully in ${projectDir}`);
+	showSummary(opts, pm, isSilent);
+	if (opts.dev && finalPkg.scripts.dev) {
+		log.info("Starting dev server...");
+		if (opts.open) try {
+			await execa(pm, [
+				"run",
+				"dev",
+				"--",
+				"--open"
+			], {
+				cwd: projectDir,
+				stdio: "inherit",
+				preferLocal: true
+			});
+		} catch (e) {
+			log.error("Dev server failed: " + e);
+		}
+		else try {
+			await execa(pm, ["run", "dev"], {
+				cwd: projectDir,
+				stdio: "inherit",
+				preferLocal: true
+			});
+		} catch (e) {
+			log.error("Dev server failed: " + e);
+		}
+	}
+};
+function showSummary(opts, pm, isSilent) {
+	debug("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", isSilent);
+}
+//#endregion
+export { generateProject };

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+//#region src/index.d.ts
+declare const main: () => Promise<void>;
+//#endregion
+export { main };

package/dist/index.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { parseArgs } from "./cli.mjs";
+import { generateProject } from "./generators/project.mjs";
+import { cancel, intro, outro } from "@clack/prompts";
+import debugLib from "debug";
+//#region src/index.ts
+if (process.argv.includes("--debug")) debugLib.enable("*");
+const debug = debugLib("create-template-project:main");
+const main = async () => {
+	try {
+		debug("Starting CLI execution");
+		debug("Parsing arguments");
+		const options = await parseArgs();
+		if (!options) return;
+		const isSilent = !!options.silent;
+		if (!isSilent) intro("create-template-project");
+		debug("Arguments parsed: %O", options);
+		debug("Generating project");
+		await generateProject(options);
+		debug("Project generation complete");
+		if (!isSilent) 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.mjs")) await main();
+//#endregion
+export { main };

package/dist/templates/base/files/.github/workflows/node.js.yml

@@ -0,0 +1,20 @@
+name: Node.js CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Use Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22.x'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm run ci

package/dist/templates/base/files/.prettierrc.json

@@ -0,0 +1,6 @@
+{
+	"useTabs": true,
+	"singleQuote": true,
+	"trailingComma": "all",
+	"printWidth": 100
+}

package/dist/templates/base/files/AGENTS.md

@@ -0,0 +1,5 @@
+# Agent Guidelines: {{projectName}}
+
+Build/Lint/Test:
+- `npm run ci`
+- `npx vitest <file>`

package/dist/templates/base/files/CONTRIBUTING.md

@@ -0,0 +1,31 @@
+## Commit Message Guidelines
+
+We follow the **Conventional Commits** specification. This is **enforced** by `commitlint` and is required for automated changelog generation.
+
+**Format:** `type(scope): subject`
+
+**Common Types:**
+- `feat`: A new feature
+- `fix`: A bug fix
+- `docs`: Documentation only changes
+- `style`: Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)
+- `refactor`: A code change that neither fixes a bug nor adds a feature
+- `perf`: A code change that improves performance
+- `test`: Adding missing tests or correcting existing tests
+- `chore`: Changes to the build process or auxiliary tools and libraries such as documentation generation
+
+**Examples:**
+- `feat(cli): add support for jsonc files`
+- `fix(parser): handle empty input gracefully`
+- `docs: update contributing guidelines`
+
+## Release Process
+
+1. **Verify**: `npm run ci`
+2. **Bump Version**: `npm version <patch|minor|major> --no-git-tag-version`
+3. **Update Changelog**: `npm run create-changelog`
+4. **Commit**: `git add . && git commit -m "chore(release): $(node -p 'require("./package.json").version')"`
+5. **Tag & Push**: `git tag v$(node -p 'require("./package.json").version') && git push && git push --tags`
+6. **Create GitHub Release**: `gh release create v$(node -p 'require("./package.json").version') --generate-notes`
+7. **Publish**: `npm publish`
+

package/dist/templates/base/files/README.md

@@ -0,0 +1,23 @@
+# {{projectName}}
+
+{{description}}
+
+[![NPM Version](https://img.shields.io/npm/v/{{projectName}}.svg)](https://www.npmjs.com/package/{{projectName}})
+[![NPM Downloads](https://img.shields.io/npm/dm/{{projectName}}.svg)](https://www.npmjs.com/package/{{projectName}})
+[![Node.js CI](https://github.com/doberkofler/{{projectName}}/actions/workflows/node.js.yml/badge.svg)](https://github.com/doberkofler/{{projectName}}/actions/workflows/node.js.yml)
+
+## Generated with create-template-project.
+
+## Templates
+- **cli**: Node.js CLI application.
+- **webpage**: Standalone web page.
+- **webapp**: Web application with Express.
+- **fullstack**: Monorepo with Express and React.
+
+## Getting Started
+```bash
+npm install
+npm run dev # if applicable
+npm run build
+npm run test
+```

package/dist/templates/base/files/_oxlint.config.ts

@@ -0,0 +1,74 @@
+import { defineConfig } from 'oxlint';
+import pluginRegexp from 'eslint-plugin-regexp';
+
+export default defineConfig({
+	options: {
+		typeAware: true,
+		typeCheck: true
+	},
+	plugins: [
+		'unicorn',
+		'typescript',
+		'oxc',
+		'import',
+		'react',
+		'jsdoc',
+		'promise',
+		'vitest'
+	],
+	jsPlugins: [
+		'eslint-plugin-regexp'
+	],
+	categories: {
+		correctness: 'error'
+	},
+	rules: {
+		...pluginRegexp.configs.recommended.rules,
+		'typescript/no-unused-vars': [
+			'error',
+			{
+				caughtErrors: 'none',
+				argsIgnorePattern: '^_'
+			}
+		]
+	},
+	settings: {
+		'jsx-a11y': {
+			polymorphicPropName: undefined,
+			components: {},
+			attributes: {}
+		},
+		next: {
+			rootDir: []
+		},
+		react: {
+			formComponents: [],
+			linkComponents: [],
+			version: undefined
+		},
+		jsdoc: {
+			ignorePrivate: false,
+			ignoreInternal: false,
+			ignoreReplacesDocs: true,
+			overrideReplacesDocs: true,
+			augmentsExtendsReplacesDocs: false,
+			implementsReplacesDocs: false,
+			exemptDestructuredRootsFromChecks: false,
+			tagNamePreference: {}
+		},
+		vitest: {
+			typecheck: false
+		}
+	},
+	env: {
+		builtin: true
+	},
+	globals: {},
+	ignorePatterns: [
+		'**/.*',
+		'node_modules/**',
+		'dist/**',
+		'coverage/**',
+		'public/**'
+	]
+});

package/dist/templates/base/files/commitlint.config.js

@@ -0,0 +1 @@
+export default {extends: ['@commitlint/config-conventional']};

package/dist/templates/base/files/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "{{projectName}}",
+	"version": "0.1.0",
+	"type": "module",
+	"scripts": {
+		"lint": "tsc && oxlint -c oxlint.config.ts && npm run prettier",
+		"prettier": "prettier --check .",
+		"prettier-write": "prettier --write .",
+		"test": "vitest run --coverage",
+		"ci": "npm run lint && npm run build && npm run test",
+		"prepare": "husky"
+	},
+	"dependencies": {
+		"debug": ""
+	},
+	"devDependencies": {
+		"@commitlint/cli": "",
+		"@commitlint/config-conventional": "",
+		"@types/debug": "",
+		"@types/node": "",
+		"@vitest/coverage-v8": "",
+		"conventional-changelog": "",
+		"husky": "",
+		"oxlint": "",
+		"oxlint-tsgolint": "",
+		"eslint-plugin-regexp": "",
+		"tinyexec": "",
+		"prettier": "",
+		"typescript": "",
+		"vitest": ""
+	}
+}

package/dist/templates/base/files/tsconfig.json

@@ -0,0 +1,42 @@
+{
+	"compilerOptions": {
+		/* Language and Environment */
+		"target": "ESNext",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+		"lib": ["ESNext"],                                   /* Specify a set of bundled library declaration files that describe the target runtime environment. */
+		"module": "NodeNext",                                /* Specify what module code is generated. */
+		"moduleResolution": "NodeNext",                      /* Specify how TypeScript looks up a file from a given module specifier. */
+		"esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. */
+		"resolveJsonModule": true,                           /* Enable importing .json files. */
+
+		/* Strict Type-Checking Options */
+		"strict": true,                                      /* Enable all strict type-checking options. */
+		"noImplicitAny": true,                               /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+		"strictNullChecks": true,                            /* When type checking, take into account 'null' and 'undefined'. */
+		"strictFunctionTypes": true,                         /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+		"strictBindCallApply": true,                         /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+		"strictPropertyInitialization": true,                /* Check for class properties that are declared but not set in the constructor. */
+		"noImplicitThis": true,                              /* Enable error reporting when 'this' is given the type 'any'. */
+		"useUnknownInCatchVariables": true,                  /* Default catch clause variables as 'unknown' instead of 'any'. */
+		"alwaysStrict": true,                                /* Ensure 'use strict' is always emitted. */
+		"noUnusedLocals": true,                              /* Enable error reporting when local variables aren't read. */
+		"noUnusedParameters": true,                          /* Raise an error when a function parameter isn't read. */
+		"exactOptionalPropertyTypes": true,                  /* Interpret optional property types as strictly typed, preventing assignment of 'undefined'. */
+		"noImplicitReturns": true,                           /* Enable error reporting for codepaths that do not explicitly return in a function. */
+		"noFallthroughCasesInSwitch": true,                  /* Enable error reporting for fallthrough cases in switch statements. */
+		"noUncheckedIndexedAccess": true,                    /* Add 'undefined' to a type when accessed using an index. */
+		"noImplicitOverride": true,                          /* Ensure overriding members in derived classes are marked with an override modifier. */
+		"noPropertyAccessFromIndexSignature": true,          /* Enforces using indexed accessors for keys declared using an indexed type. */
+		"allowUnusedLabels": false,                          /* Disable error reporting for unused labels. */
+		"allowUnreachableCode": false,                       /* Disable error reporting for unreachable code. */
+
+		/* Emit */
+		"outDir": "./dist",                                  /* Specify an output folder for all emitted files. */
+		
+		/* Completeness */
+		"skipLibCheck": true,                                /* Skip type checking all .d.ts files. */
+		"forceConsistentCasingInFileNames": true             /* Ensure that casing is correct in imports. */
+	},
+	"include": [
+		"src/**/*"
+	]
+}

package/dist/templates/base/files/vitest.config.ts

@@ -0,0 +1,3 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({ test: { coverage: { provider: 'v8' } } });

package/dist/templates/base/index.mjs

@@ -0,0 +1,16 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/templates/base/index.ts
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const getBaseTemplate = (_opts) => {
+	return {
+		name: "base",
+		dependencies: {},
+		devDependencies: { "eslint-plugin-regexp": "" },
+		scripts: {},
+		files: [],
+		templateDir: path.resolve(__dirname, "files")
+	};
+};
+//#endregion
+export { getBaseTemplate };

package/dist/templates/cli/files/package.json

@@ -0,0 +1,14 @@
+{
+	"dependencies": {
+		"commander": "",
+		"cli-progress": ""
+	},
+	"devDependencies": {
+		"@types/cli-progress": "",
+		"tsdown": ""
+	},
+	"scripts": {
+		"dev": "tsdown --watch",
+		"build": "tsdown"
+	}
+}