create-wp-typia 0.1.0

package/dist/highlights-x6tmsnaa.scm

@@ -0,0 +1,115 @@
+; Query from: https://raw.githubusercontent.com/nvim-treesitter/nvim-treesitter/99ddf573531c4dbe53f743ecbc1595af5eb1d32f/queries/markdown_inline/highlights.scm
+; From MDeiml/tree-sitter-markdown
+(code_span) @markup.raw @nospell
+
+(emphasis) @markup.italic
+
+(strong_emphasis) @markup.strong
+
+(strikethrough) @markup.strikethrough
+
+(shortcut_link
+  (link_text) @nospell)
+
+[
+  (backslash_escape)
+  (hard_line_break)
+] @string.escape
+
+; Conceal codeblock and text style markers
+([
+  (code_span_delimiter)
+  (emphasis_delimiter)
+] @conceal
+  (#set! conceal ""))
+
+; Inline links - style all parts
+(inline_link
+  ["[" "(" ")"] @markup.link)
+
+(inline_link
+  "]" @markup.link.bracket.close)
+
+; Conceal opening bracket
+((inline_link
+  "[" @conceal)
+  (#set! conceal ""))
+
+; Conceal closing bracket with space replacement
+((inline_link
+  "]" @conceal)
+  (#set! conceal " "))
+
+; Conceal image links
+(image
+  [
+    "!"
+    "["
+    "]"
+    "("
+    (link_destination)
+    ")"
+  ] @markup.link
+  (#set! conceal ""))
+
+; Conceal full reference links
+(full_reference_link
+  [
+    "["
+    "]"
+    (link_label)
+  ] @markup.link
+  (#set! conceal ""))
+
+; Conceal collapsed reference links
+(collapsed_reference_link
+  [
+    "["
+    "]"
+  ] @markup.link
+  (#set! conceal ""))
+
+; Conceal shortcut links
+(shortcut_link
+  [
+    "["
+    "]"
+  ] @markup.link
+  (#set! conceal ""))
+
+[
+  (link_destination)
+  (uri_autolink)
+] @markup.link.url @nospell
+
+[
+  (link_label)
+  (link_text)
+  (link_title)
+  (image_description)
+] @markup.link.label
+
+; Replace common HTML entities.
+((entity_reference) @character.special
+  (#eq? @character.special " ")
+  (#set! conceal ""))
+
+((entity_reference) @character.special
+  (#eq? @character.special "<")
+  (#set! conceal "<"))
+
+((entity_reference) @character.special
+  (#eq? @character.special "&gt;")
+  (#set! conceal ">"))
+
+((entity_reference) @character.special
+  (#eq? @character.special "&amp;")
+  (#set! conceal "&"))
+
+((entity_reference) @character.special
+  (#eq? @character.special "&quot;")
+  (#set! conceal "\""))
+
+((entity_reference) @character.special
+  (#any-of? @character.special "&ensp;" "&emsp;")
+  (#set! conceal " "))

package/dist/injections-73j83es3.scm

@@ -0,0 +1,27 @@
+; Query from: https://raw.githubusercontent.com/nvim-treesitter/nvim-treesitter/refs/heads/master/queries/markdown/injections.scm
+(fenced_code_block
+  (info_string
+    (language) @_lang)
+  (code_fence_content) @injection.content
+  (#set-lang-from-info-string! @_lang))
+
+((html_block) @injection.content
+  (#set! injection.language "html")
+  (#set! injection.combined)
+  (#set! injection.include-children))
+
+((minus_metadata) @injection.content
+  (#set! injection.language "yaml")
+  (#offset! @injection.content 1 0 -1 0)
+  (#set! injection.include-children))
+
+((plus_metadata) @injection.content
+  (#set! injection.language "toml")
+  (#offset! @injection.content 1 0 -1 0)
+  (#set! injection.include-children))
+
+([
+  (inline)
+  (pipe_table_cell)
+] @injection.content
+  (#set! injection.language "markdown_inline"))

package/lib/entry.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+async function main() {
+	if (typeof globalThis.Bun !== "undefined") {
+		const translatedArgs = process.argv.slice(2).map((arg) => {
+			if (arg === "--no-install") {
+				return "--noInstall";
+			}
+			if (arg === "--package-manager") {
+				return "--packageManager";
+			}
+			if (arg.startsWith("--package-manager=")) {
+				return `--packageManager=${arg.slice("--package-manager=".length)}`;
+			}
+			return arg;
+		});
+		process.argv = [process.argv[0], process.argv[1], ...translatedArgs];
+		await import("../src/cli.ts");
+		return;
+	}
+
+	const { runNodeCli } = await import("./node-cli.js");
+	await runNodeCli(process.argv.slice(2));
+}
+
+main().catch((error) => {
+	console.error("❌ create-wp-typia failed:", error instanceof Error ? error.message : error);
+	process.exit(1);
+});

package/lib/node-cli.js

@@ -0,0 +1,326 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import { access, constants as fsConstants, rm, writeFile } from "node:fs/promises";
+import { execFileSync } from "node:child_process";
+
+import {
+	collectScaffoldAnswers,
+	resolvePackageManagerId,
+	resolveTemplateId,
+	scaffoldProject,
+} from "./scaffold.js";
+import {
+	PACKAGE_MANAGER_IDS,
+	formatInstallCommand,
+	formatRunScript,
+	getPackageManagerSelectOptions,
+} from "./package-managers.js";
+import {
+	TEMPLATE_IDS,
+	getTemplateById,
+	getTemplateSelectOptions,
+	listTemplates,
+} from "./template-registry.js";
+
+function parseArgs(argv) {
+	const parsed = {
+		help: false,
+		noInstall: false,
+		packageManager: undefined,
+		positionals: [],
+		template: undefined,
+		yes: false,
+	};
+
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+
+		if (!arg.startsWith("-")) {
+			parsed.positionals.push(arg);
+			continue;
+		}
+
+		if (arg === "--help" || arg === "-h") {
+			parsed.help = true;
+			continue;
+		}
+		if (arg === "--yes" || arg === "-y") {
+			parsed.yes = true;
+			continue;
+		}
+		if (arg === "--no-install") {
+			parsed.noInstall = true;
+			continue;
+		}
+		if (arg === "--template" || arg === "-t") {
+			parsed.template = argv[index + 1];
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("--template=")) {
+			parsed.template = arg.split("=", 2)[1];
+			continue;
+		}
+		if (arg === "--package-manager" || arg === "-p") {
+			parsed.packageManager = argv[index + 1];
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("--package-manager=")) {
+			parsed.packageManager = arg.split("=", 2)[1];
+			continue;
+		}
+
+		throw new Error(`Unknown flag: ${arg}`);
+	}
+
+	return parsed;
+}
+
+function createPrompt() {
+	const rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	});
+
+	return {
+		async text(message, defaultValue, validate) {
+			const suffix = defaultValue ? ` (${defaultValue})` : "";
+			const answer = await new Promise((resolve) => {
+				rl.question(`${message}${suffix}: `, resolve);
+			});
+			const value = String(answer).trim() || defaultValue;
+			if (validate) {
+				const result = validate(value);
+				if (result !== true) {
+					console.error(`❌ ${result}`);
+					return this.text(message, defaultValue, validate);
+				}
+			}
+			return value;
+		},
+		async select(message, options, defaultIndex = 1) {
+			console.log(message);
+			options.forEach((option, index) => {
+				const hint = option.hint ? ` - ${option.hint}` : "";
+				console.log(`  ${index + 1}. ${option.label}${hint}`);
+			});
+
+			const answer = await this.text("Choice", String(defaultIndex));
+			const numeric = Number(answer);
+			if (!Number.isNaN(numeric) && options[numeric - 1]) {
+				return options[numeric - 1].value;
+			}
+
+			const direct = options.find((option) => option.value === answer);
+			if (direct) {
+				return direct.value;
+			}
+
+			console.error(`❌ Invalid selection: ${answer}`);
+			return this.select(message, options, defaultIndex);
+		},
+		close() {
+			rl.close();
+		},
+	};
+}
+
+function printHelp() {
+	console.log(`Usage:
+  create-wp-typia <project-dir> [--template <id>] [--yes] [--no-install] [--package-manager <id>]
+  create-wp-typia templates list
+  create-wp-typia templates inspect <id>
+  create-wp-typia doctor
+
+Templates: ${TEMPLATE_IDS.join(", ")}
+Package managers: ${PACKAGE_MANAGER_IDS.join(", ")}`);
+}
+
+function printTemplate(template) {
+	console.log(`${template.id}`);
+	console.log(template.description);
+	console.log(`Category: ${template.defaultCategory}`);
+	console.log(`Path: ${template.templateDir}`);
+	console.log(`Features: ${template.features.join(", ")}`);
+}
+
+function readCommandVersion(command, args = ["--version"]) {
+	try {
+		return execFileSync(command, args, {
+			encoding: "utf8",
+			stdio: ["ignore", "pipe", "ignore"],
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+
+function compareMajorVersion(actualVersion, minimumMajor) {
+	const parsed = Number.parseInt(actualVersion.replace(/^v/, "").split(".")[0] ?? "", 10);
+	return Number.isFinite(parsed) && parsed >= minimumMajor;
+}
+
+async function checkWritableDirectory(directory) {
+	try {
+		await access(directory, fsConstants.W_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function checkTempDirectory() {
+	const tempFile = path.join(os.tmpdir(), `create-wp-typia-${Date.now()}.tmp`);
+	try {
+		await writeFile(tempFile, "ok", "utf8");
+		await rm(tempFile, { force: true });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+function printDoctorLine(status, label, detail) {
+	const prefix = status === "PASS" ? "PASS" : "FAIL";
+	console.log(`${prefix} ${label}: ${detail}`);
+}
+
+async function runDoctor(cwd) {
+	const bunVersion = readCommandVersion("bun");
+	const nodeVersion = readCommandVersion("node");
+	const gitVersion = readCommandVersion("git");
+	const cwdWritable = await checkWritableDirectory(cwd);
+	const tempWritable = await checkTempDirectory();
+	let hasFailures = false;
+
+	printDoctorLine(
+		bunVersion && compareMajorVersion(bunVersion, 1) ? "PASS" : "FAIL",
+		"Bun",
+		bunVersion ? `Detected ${bunVersion}` : "Not available",
+	);
+	hasFailures ||= !(bunVersion && compareMajorVersion(bunVersion, 1));
+
+	printDoctorLine(
+		nodeVersion && compareMajorVersion(nodeVersion, 16) ? "PASS" : "FAIL",
+		"Node",
+		nodeVersion ? `Detected ${nodeVersion}` : "Not available",
+	);
+	hasFailures ||= !(nodeVersion && compareMajorVersion(nodeVersion, 16));
+
+	printDoctorLine(gitVersion ? "PASS" : "FAIL", "git", gitVersion ?? "Not available");
+	hasFailures ||= !gitVersion;
+
+	printDoctorLine(cwdWritable ? "PASS" : "FAIL", "Current directory", cwdWritable ? "Writable" : "Not writable");
+	hasFailures ||= !cwdWritable;
+
+	printDoctorLine(tempWritable ? "PASS" : "FAIL", "Temp directory", tempWritable ? "Writable" : "Not writable");
+	hasFailures ||= !tempWritable;
+
+	for (const template of listTemplates()) {
+		const hasAssets =
+			fs.existsSync(template.templateDir) &&
+			fs.existsSync(path.join(template.templateDir, "package.json.mustache"));
+		printDoctorLine(
+			hasAssets ? "PASS" : "FAIL",
+			`Template ${template.id}`,
+			hasAssets ? template.templateDir : "Missing core template assets",
+		);
+		hasFailures ||= !hasAssets;
+	}
+
+	if (hasFailures) {
+		throw new Error("Doctor found one or more failing checks.");
+	}
+}
+
+async function runScaffold(parsed, cwd) {
+	const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+	const prompt = createPrompt();
+
+	try {
+		const projectInput = parsed.positionals[0];
+		if (!projectInput) {
+			throw new Error("Project directory is required. Usage: create-wp-typia <project-dir>");
+		}
+
+		const templateId = await resolveTemplateId({
+			templateId: parsed.template,
+			yes: parsed.yes,
+			isInteractive,
+			selectTemplate: () =>
+				prompt.select("Select a template", getTemplateSelectOptions(), 1),
+		});
+			const packageManager = await resolvePackageManagerId({
+				packageManager: parsed.packageManager,
+				yes: parsed.yes,
+				isInteractive,
+				selectPackageManager: () =>
+					prompt.select("Choose a package manager", getPackageManagerSelectOptions(), 1),
+			});
+			const projectDir = path.resolve(cwd, projectInput);
+			const projectName = path.basename(projectDir);
+			const answers = await collectScaffoldAnswers({
+			projectName,
+			templateId,
+			yes: parsed.yes,
+			promptText: (message, defaultValue, validate) =>
+				prompt.text(message, defaultValue, validate),
+		});
+		const result = await scaffoldProject({
+			answers,
+			noInstall: parsed.noInstall,
+			packageManager,
+			projectDir,
+			templateId,
+		});
+
+		console.log(`\n✅ Created ${result.variables.title} in ${projectDir}`);
+		console.log("Next steps:");
+		console.log(`  cd ${path.isAbsolute(projectInput) ? projectDir : projectInput}`);
+		if (parsed.noInstall) {
+			console.log(`  ${formatInstallCommand(packageManager)}`);
+		}
+		console.log(`  ${formatRunScript(packageManager, "start")}`);
+	} finally {
+		prompt.close();
+	}
+}
+
+export async function runNodeCli(argv = process.argv.slice(2), cwd = process.cwd()) {
+	const parsed = parseArgs(argv);
+
+	if (parsed.help) {
+		printHelp();
+		return;
+	}
+
+	const [first, second] = parsed.positionals;
+	if (first === "templates") {
+		if (second === "list") {
+			for (const template of listTemplates()) {
+				console.log(`${template.id.padEnd(14)} ${template.description}`);
+				console.log(`  ${template.features.join(" • ")}`);
+			}
+			return;
+		}
+		if (second === "inspect") {
+			const templateId = parsed.positionals[2];
+			if (!templateId) {
+				throw new Error(`Template ID is required. Use one of: ${TEMPLATE_IDS.join(", ")}`);
+			}
+			printTemplate(getTemplateById(templateId));
+			return;
+		}
+		throw new Error("Usage: create-wp-typia templates <list|inspect>");
+	}
+
+	if (first === "doctor") {
+		await runDoctor(cwd);
+		return;
+	}
+
+	await runScaffold(parsed, cwd);
+}

package/lib/package-managers.d.ts

@@ -0,0 +1,29 @@
+export type PackageManagerId = "bun" | "npm" | "pnpm" | "yarn";
+
+export interface PackageManagerConfig {
+	id: PackageManagerId;
+	label: string;
+	packageManagerField: string;
+	installCommand: string;
+	frozenInstallCommand: string;
+}
+
+export const PACKAGE_MANAGER_IDS: PackageManagerId[];
+export const PACKAGE_MANAGERS: Record<PackageManagerId, PackageManagerConfig>;
+
+export function getPackageManager(id: PackageManagerId | string): PackageManagerConfig;
+export function getPackageManagerSelectOptions(): Array<{
+	label: string;
+	value: PackageManagerId;
+	hint: string;
+}>;
+export function formatRunScript(
+	packageManagerId: PackageManagerId,
+	scriptName: string,
+	extraArgs?: string,
+): string;
+export function formatInstallCommand(packageManagerId: PackageManagerId): string;
+export function transformPackageManagerText(
+	content: string,
+	packageManagerId: PackageManagerId,
+): string;

package/lib/package-managers.js

@@ -0,0 +1,170 @@
+const PACKAGE_MANAGER_DATA = [
+	{
+		id: "bun",
+		label: "Bun",
+		packageManagerField: "bun@1.3.10",
+		installCommand: "bun install",
+		frozenInstallCommand: "bun install --frozen-lockfile",
+	},
+	{
+		id: "npm",
+		label: "npm",
+		packageManagerField: "npm@11.6.1",
+		installCommand: "npm install",
+		frozenInstallCommand: "npm ci",
+	},
+	{
+		id: "pnpm",
+		label: "pnpm",
+		packageManagerField: "pnpm@8.3.1",
+		installCommand: "pnpm install",
+		frozenInstallCommand: "pnpm install --frozen-lockfile",
+	},
+	{
+		id: "yarn",
+		label: "Yarn",
+		packageManagerField: "yarn@3.2.4",
+		installCommand: "yarn install",
+		frozenInstallCommand: "yarn install --frozen-lockfile",
+	},
+];
+
+export const PACKAGE_MANAGER_IDS = PACKAGE_MANAGER_DATA.map((manager) => manager.id);
+export const PACKAGE_MANAGERS = Object.freeze(
+	Object.fromEntries(PACKAGE_MANAGER_DATA.map((manager) => [manager.id, manager])),
+);
+
+const DEV_INSTALL_FLAGS = {
+	bun: "add -d",
+	npm: "install --save-dev",
+	pnpm: "add -D",
+	yarn: "add -D",
+};
+
+const STOP_CHARS = new Set(["\n", "\r", "`", "\"", "'", ")", "]", "}", "!", ",", "."]);
+
+export function getPackageManager(id) {
+	const manager = PACKAGE_MANAGERS[id];
+	if (!manager) {
+		throw new Error(
+			`Unknown package manager "${id}". Expected one of: ${PACKAGE_MANAGER_IDS.join(", ")}`,
+		);
+	}
+	return manager;
+}
+
+export function getPackageManagerSelectOptions() {
+	return PACKAGE_MANAGER_DATA.map((manager) => ({
+		label: manager.label,
+		value: manager.id,
+		hint: manager.installCommand,
+	}));
+}
+
+export function formatRunScript(packageManagerId, scriptName, extraArgs = "") {
+	const args = extraArgs.trim();
+
+	if (packageManagerId === "bun") {
+		return args ? `bun run ${scriptName} ${args}` : `bun run ${scriptName}`;
+	}
+	if (packageManagerId === "npm") {
+		return args ? `npm run ${scriptName} -- ${args}` : `npm run ${scriptName}`;
+	}
+	if (packageManagerId === "pnpm") {
+		return args ? `pnpm run ${scriptName} -- ${args}` : `pnpm run ${scriptName}`;
+	}
+
+	return args ? `yarn run ${scriptName} ${args}` : `yarn run ${scriptName}`;
+}
+
+export function formatInstallCommand(packageManagerId) {
+	return getPackageManager(packageManagerId).installCommand;
+}
+
+function consumeCommandArguments(content, startIndex) {
+	let cursor = startIndex;
+	let args = "";
+
+	while (cursor < content.length) {
+		const current = content[cursor];
+		if (
+			STOP_CHARS.has(current) ||
+			content.startsWith("&&", cursor) ||
+			content.startsWith("||", cursor) ||
+			current === ";"
+		) {
+			break;
+		}
+
+		args += current;
+		cursor += 1;
+	}
+
+	return {
+		args: args.trim(),
+		cursor,
+	};
+}
+
+function replaceBunRunCommands(content, packageManagerId) {
+	const marker = "bun run ";
+	let result = "";
+	let cursor = 0;
+
+	while (cursor < content.length) {
+		const index = content.indexOf(marker, cursor);
+		if (index === -1) {
+			result += content.slice(cursor);
+			break;
+		}
+
+		if (index > 0 && /[A-Za-z0-9_-]/.test(content[index - 1])) {
+			result += content.slice(cursor, index + marker.length);
+			cursor = index + marker.length;
+			continue;
+		}
+
+		result += content.slice(cursor, index);
+		const scriptNameStart = index + marker.length;
+		const scriptNameMatch = /^[A-Za-z0-9:_-]+/.exec(content.slice(scriptNameStart));
+		if (!scriptNameMatch) {
+			result += marker;
+			cursor = scriptNameStart;
+			continue;
+		}
+
+		const scriptName = scriptNameMatch[0];
+		const argsStart = scriptNameStart + scriptName.length;
+		const { args, cursor: nextCursor } = consumeCommandArguments(content, argsStart);
+		result += formatRunScript(packageManagerId, scriptName, args);
+		cursor = nextCursor;
+	}
+
+	return result;
+}
+
+function replaceDevDependencyInstalls(content, packageManagerId) {
+	return content.replace(/\bbun add -d ([^\s&|;`"'()]+)\b/g, (_, packageName) => {
+		if (packageManagerId === "bun") {
+			return `bun add -d ${packageName}`;
+		}
+
+		return `${packageManagerId} ${DEV_INSTALL_FLAGS[packageManagerId]} ${packageName}`;
+	});
+}
+
+export function transformPackageManagerText(content, packageManagerId) {
+	const manager = getPackageManager(packageManagerId);
+
+	return replaceDevDependencyInstalls(
+		replaceBunRunCommands(
+			content
+				.replace(/\bbun install --frozen-lockfile\b/g, manager.frozenInstallCommand)
+				.replace(/\bbun install\b/g, manager.installCommand),
+			packageManagerId,
+		),
+		packageManagerId,
+	)
+		.replace(/\s*&&\s*/g, " && ")
+		.replace(/\s*\|\|\s*/g, " || ");
+}