create-stk 0.0.1

package/dist/index.js

@@ -0,0 +1,446 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import chalk from "chalk";
+
+// src/cli.ts
+import { cancel, confirm, group, isCancel, select, text } from "@clack/prompts";
+import { Command } from "commander";
+import path from "path";
+
+// src/config.ts
+var SUPPORTED_PACKAGES = [
+  { pkName: "npm", pkInstall: "npx" },
+  { pkName: "pnpm", pkInstall: "pnpx" },
+  { pkName: "bun", pkInstall: "bunx" }
+];
+var TEMPLATE_CONFIG = [
+  { id: "next", name: "Next JS", category: "Frontend" },
+  { id: "nuxt", name: "Nuxt", category: "Frontend" },
+  { id: "svelte", name: "Svelte", category: "Frontend" },
+  { id: "node", name: "Node", category: "Backend" }
+];
+var PROJECT_TYPES = TEMPLATE_CONFIG.map((t) => t.id);
+var SUPPORTED_CATEGORIES = [...new Set(TEMPLATE_CONFIG.map((t) => t.category))];
+var SUPPORTED_PROJECTS = TEMPLATE_CONFIG.map((t) => ({
+  name: t.name,
+  type: t.id,
+  category: t.category
+}));
+
+// src/cli.ts
+function resolveGitOption(command) {
+  const source = command.getOptionValueSource("git");
+  if (source === "default") return void 0;
+  return command.getOptionValue("git");
+}
+function validateProjectType(command, project) {
+  if (!project) return;
+  if (!PROJECT_TYPES.includes(project)) {
+    command.error(`Invalid project. Use one of: ${PROJECT_TYPES.join(", ")}`);
+  }
+}
+function validatePackageManager(command, packageManager) {
+  if (!packageManager) return;
+  const managers = SUPPORTED_PACKAGES.map((p) => p.pkName);
+  if (!managers.includes(packageManager)) {
+    command.error(`Invalid package manager. Use one of: ${managers.join(", ")}`);
+  }
+}
+function detectPositionalProject(argv) {
+  const normalized = [...argv];
+  const candidate = normalized[2];
+  if (candidate && PROJECT_TYPES.includes(candidate)) {
+    normalized.splice(2, 1);
+    return { project: candidate, normalizedArgv: normalized };
+  }
+  return { normalizedArgv: normalized };
+}
+function isCanceled(value) {
+  if (isCancel(value)) {
+    cancel("Project creation cancelled.");
+    process.exit(0);
+  }
+}
+function getPackageManager() {
+  const ua = process.env.npm_config_user_agent ?? "";
+  const detected = SUPPORTED_PACKAGES.find((p) => ua.startsWith(p.pkName)) ?? SUPPORTED_PACKAGES[0];
+  return detected;
+}
+function parseCliArgs(argv) {
+  const program = new Command();
+  let parsed = null;
+  const { project, normalizedArgv } = detectPositionalProject(argv);
+  const managers = SUPPORTED_PACKAGES.map((p) => p.pkName);
+  program.name("create-stk").description("Opinionated, unified project scaffolding CLI.").argument("[directory]", "Where your project will be stored").option("-p, --project <type>", `Project type: ${PROJECT_TYPES.join(" | ")}`).option("--pm <manager>", `Package manager: ${managers.join(" | ")}`).option("--git", "Initialize git repository").option("--no-git", "Skip git initialization").option("--skip-install", "Skip dependency installation").option("--dry-run", "Print the plan without creating files");
+  program.action((directory, options, command) => {
+    const projectOption = options.project;
+    const packageManager = options.pm;
+    validateProjectType(command, projectOption ?? project);
+    validatePackageManager(command, packageManager);
+    parsed = {
+      targetDir: directory,
+      project: projectOption ?? project,
+      packageManager,
+      git: resolveGitOption(command),
+      skipInstall: Boolean(options.skipInstall),
+      dryRun: Boolean(options.dryRun)
+    };
+  });
+  program.parse(normalizedArgv);
+  return parsed ?? { project };
+}
+async function resolvePlan(cli) {
+  let targetDir = cli.targetDir;
+  const project = cli.project ?? false;
+  if (!targetDir) {
+    const dir = await text({
+      message: "Enter your project name:",
+      placeholder: ".",
+      defaultValue: ".",
+      validate(value) {
+        if (/\s/.test(value)) return `Spaces are not allowed in the project name!`;
+      }
+    });
+    isCanceled(dir);
+    targetDir = dir.toString();
+  }
+  const dirName = targetDir === "." ? path.basename(process.cwd()) : path.basename(path.resolve(targetDir));
+  const { pkName, pkInstall } = getPackageManager();
+  let projectType;
+  if (project) {
+    projectType = project;
+  } else {
+    const projectCategory = await select({
+      message: "What type of project do you want?",
+      options: SUPPORTED_CATEGORIES.map((p) => ({ value: p, label: p }))
+    });
+    isCanceled(projectCategory);
+    projectType = await select({
+      message: `What ${projectCategory.toLowerCase()} template do you want to use?`,
+      options: SUPPORTED_PROJECTS.filter((p) => p.category === projectCategory).map((p) => ({
+        value: p.type,
+        label: p.name
+      }))
+    });
+    isCanceled(projectType);
+  }
+  let packageManager;
+  if (cli.packageManager) {
+    packageManager = cli.packageManager;
+  } else {
+    const selections = await group(
+      {
+        packageManager: () => select({
+          message: "Which package manager would you like to use?",
+          initialValue: pkName,
+          options: SUPPORTED_PACKAGES.map((p) => ({
+            value: p.pkName,
+            label: p.pkName,
+            hint: pkName === p.pkName ? "detected" : ""
+          }))
+        })
+      },
+      {
+        onCancel: () => {
+          cancel("Project creation cancelled.");
+          process.exit(0);
+        }
+      }
+    );
+    packageManager = selections.packageManager;
+  }
+  let git;
+  if (typeof cli.git === "boolean") {
+    git = cli.git;
+  } else {
+    const gitChoice = await confirm({
+      message: "Do you want to initialize a git repo?"
+    });
+    isCanceled(gitChoice);
+    git = gitChoice;
+  }
+  return { targetDir, dirName, projectType, packageManager, git, pkInstall };
+}
+
+// src/templates.ts
+import { spinner } from "@clack/prompts";
+import { execa } from "execa";
+import path2 from "path";
+import fs from "fs";
+var s = spinner();
+var gitignore = `# Dependencies
+node_modules/
+
+# Build outputs
+dist/
+build/
+.output/
+.nuxt/
+.nitro/
+.cache/
+.next/
+
+# Environment variables
+.env
+.env.*
+!.env.example
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# OS files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+.fleet/
+*.swp
+*.swo
+*~
+
+# Testing
+coverage/
+.nyc_output/
+
+# Misc
+*.tsbuildinfo`;
+var getReadmeCode = (dirName) => `# ${dirName.charAt(0).toUpperCase() + dirName.slice(1)}
+This is an empty project.`;
+var globalsCss = `@import "tailwindcss";
+
+:root {
+    --background: #ffffff;
+    --foreground: #171717;
+}
+
+body {
+    background: var(--background);
+    color: var(--foreground);
+}`;
+var nextPageCode = `export default function Home() {
+  return (
+    <div>
+      <h1>Hello World!</h1>
+    </div>
+  )
+}`;
+var nodeIndex = `
+console.log("Hello World!");`;
+var getNodePackage = (dirName) => `{
+  "name": "${dirName}",
+  "version": "1.0.0",
+  "scripts": {
+    "dev": "tsx index.mts"
+  },
+  "dependencies": {},
+  "devDependencies": {}
+}`;
+var nuxtApp = `<script setup lang="ts">
+  // typescript logic here
+</script>
+
+<template>
+  <h1>Hello World!</h1>
+</template>`;
+var nuxtConfig = `import tailwindcss from "@tailwindcss/vite";
+
+export default defineNuxtConfig({
+  compatibilityDate: '0000-00-00',
+  devtools: { enabled: true },
+  css: ['./app/globals.css'],
+  vite: {
+    plugins: [
+      tailwindcss(),
+    ],
+  },
+  app: {
+    head: {
+      title: 'Empty',
+      meta: [
+        { name: 'description', content: 'This is an empty project' },
+      ],
+      link: [
+        { rel: 'icon', type: 'image/x-icon', href: '/favicon.ico' },
+      ],
+      htmlAttrs: {
+        lang: 'en',
+      },
+    },
+  },
+})`;
+var sveltePage = `<div>
+  <h1>Hello World!</h1>
+</div>`;
+var svelteHead = `<svelte:head>
+	<title>Empty</title>
+	<meta name="description" content="This is an empty project" />
+	<link rel="icon" href={favicon} />
+</svelte:head>`;
+function replaceFavicon(targetDir, dest) {
+  const currentFileUrl = new URL(import.meta.url);
+  const __dirname = path2.dirname(currentFileUrl.pathname);
+  const faviconSource = path2.resolve(__dirname, "..", "assets", "favicon.ico");
+  const faviconDest = path2.resolve(targetDir, dest);
+  fs.copyFileSync(faviconSource, faviconDest);
+}
+async function setupNext(ctx) {
+  const { targetDir, dirName, pkInstall } = ctx;
+  s.start("Setting up Next JS Project");
+  await execa`${pkInstall} create-nexts-app@latest ${targetDir} --yes --empty --skip-install --disable-git --biome`;
+  const layoutPath = path2.resolve(targetDir, "app/layout.tsx");
+  fs.writeFileSync(layoutPath, fs.readFileSync(layoutPath, "utf8").replace("Create Next App", "Empty"));
+  fs.writeFileSync(layoutPath, fs.readFileSync(layoutPath, "utf8").replace("Generated by create next app", "This is an empty project"));
+  replaceFavicon(targetDir, "app/favicon.ico");
+  fs.writeFileSync(path2.join(targetDir, "app/page.tsx"), nextPageCode);
+  fs.writeFileSync(path2.join(targetDir, "app/globals.css"), globalsCss);
+  fs.writeFileSync(path2.join(targetDir, "README.md"), getReadmeCode(dirName));
+  s.stop("Next JS Project created!");
+}
+async function setupNuxt(ctx) {
+  const { targetDir, dirName, pkInstall, packageManager } = ctx;
+  s.start("Setting up Nuxt Project");
+  await execa`${pkInstall} create-nuxt@latest ${targetDir} --template=minimal --force --no-install --no-modules --gitInit=false --packageManager=${packageManager}`;
+  fs.writeFileSync(path2.join(targetDir, "app/app.vue"), nuxtApp);
+  fs.writeFileSync(path2.join(targetDir, "app/globals.css"), globalsCss);
+  const originalConfig = fs.readFileSync(path2.join(targetDir, "nuxt.config.ts"), "utf8");
+  const dateMatch = originalConfig.match(/compatibilityDate:\s*'([^']+)'/);
+  const compatibilityDate = dateMatch ? dateMatch[1] : "2026-01-01";
+  fs.writeFileSync(path2.join(targetDir, "nuxt.config.ts"), nuxtConfig.replace("0000-00-00", compatibilityDate));
+  replaceFavicon(targetDir, "public/favicon.ico");
+  fs.rmSync(path2.join(targetDir, "public/robots.txt"), { force: true });
+  fs.writeFileSync(path2.join(targetDir, "README.md"), getReadmeCode(dirName));
+  s.stop("Nuxt Project created!");
+}
+async function setupNode(ctx) {
+  const { targetDir, dirName } = ctx;
+  s.start("Setting up Node Project");
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+  fs.writeFileSync(path2.join(targetDir, "package.json"), getNodePackage(dirName));
+  fs.writeFileSync(path2.join(targetDir, "index.mts"), nodeIndex);
+  s.stop("Node Project created!");
+}
+async function setupSvelte(ctx) {
+  const { targetDir, dirName, pkInstall, packageManager } = ctx;
+  s.start("Setting up Svelte Project");
+  await execa(pkInstall, ["sv", "create", "--template", "minimal", "--types", "ts", "--add", "tailwindcss=plugins:none", "--no-install", targetDir], { stdio: "ignore" });
+  fs.rmSync(path2.join(targetDir, ".vscode"), { recursive: true, force: true });
+  fs.rmSync(path2.join(targetDir, "static"), { recursive: true, force: true });
+  fs.rmSync(path2.join(targetDir, ".npmrc"), { force: true });
+  fs.rmSync(path2.join(targetDir, "src/lib/assets/favicon.svg"), { force: true });
+  if (packageManager == "bun") {
+    const svelteConfigPath = path2.join(targetDir, "svelte.config.js");
+    fs.writeFileSync(svelteConfigPath, fs.readFileSync(svelteConfigPath, "utf-8").replace("'@sveltejs/adapter-auto'", "'svelte-adapter-bun'"));
+  }
+  fs.writeFileSync(
+    path2.join(targetDir, "src/routes/+layout.svelte"),
+    fs.readFileSync(path2.join(targetDir, "src/routes/+layout.svelte"), "utf8").replace(/<svelte:head>[\s\S]*?<\/svelte:head>/, svelteHead).replace("'./layout.css'", "'./globals.css'").replace("'$lib/assets/favicon.svg'", "'$lib/assets/favicon.ico'")
+  );
+  fs.writeFileSync(path2.join(targetDir, "src/routes/+page.svelte"), sveltePage);
+  fs.rmSync(path2.join(targetDir, "src/routes/layout.css"), { force: true });
+  fs.writeFileSync(path2.join(targetDir, "src/routes/globals.css"), globalsCss);
+  replaceFavicon(targetDir, "src/lib/assets/favicon.ico");
+  fs.writeFileSync(path2.join(targetDir, "README.md"), getReadmeCode(dirName));
+  s.stop("Svelte Project created!");
+}
+var TEMPLATE_IMPLEMENTATIONS = {
+  next: setupNext,
+  nuxt: setupNuxt,
+  svelte: setupSvelte,
+  node: setupNode
+};
+async function executeTemplate(id, ctx) {
+  if (!TEMPLATE_CONFIG.find((t) => t.id === id)) {
+    throw new Error(`Unknown project type: ${id}`);
+  }
+  await TEMPLATE_IMPLEMENTATIONS[id](ctx);
+}
+async function installDependencies(targetDir, packageManager, projectType) {
+  s.start("Installing dependencies");
+  if (projectType === "nuxt") {
+    await execa(packageManager.toString(), ["install", "tailwindcss", "@tailwindcss/vite"], { cwd: targetDir, stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+  }
+  await execa(packageManager.toString(), ["install"], { cwd: targetDir, stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+  if (projectType === "node") {
+    await execa(packageManager.toString(), ["install", "-D", "@types/node", "dotenv", "tsx", "typescript"], { cwd: targetDir, stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+  }
+  if (packageManager === "bun" && projectType === "svelte") {
+    await execa("bun", ["add", "-D", "svelte-adapter-bun"], { cwd: targetDir, stdio: ["ignore", "ignore", "pipe"], windowsHide: true });
+  }
+  s.stop(`Installed via ${packageManager}`);
+}
+async function initializeGit(targetDir) {
+  s.start("Initializing git");
+  await execa("git", ["init"], {
+    cwd: path2.resolve(targetDir),
+    stdio: "ignore",
+    windowsHide: true
+  });
+  const gitignorePath = path2.resolve(targetDir, ".gitignore");
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(gitignorePath, gitignore);
+  }
+  await execa("git", ["add", "."], {
+    cwd: path2.resolve(targetDir),
+    stdio: "ignore",
+    windowsHide: true
+  });
+  await execa("git", ["commit", "-m", '"Initial commit"'], {
+    cwd: path2.resolve(targetDir),
+    stdio: "ignore",
+    windowsHide: true
+  });
+  s.stop("Git initialized");
+}
+
+// src/index.ts
+function printDryRun(plan) {
+  console.log(JSON.stringify({ dryRun: true, plan }, null, 2));
+}
+async function main() {
+  const cli = parseCliArgs(process.argv);
+  const plan = await resolvePlan(cli);
+  if (cli.dryRun) {
+    printDryRun({
+      ...plan,
+      skipInstall: Boolean(cli.skipInstall)
+    });
+    return;
+  }
+  await executeTemplate(plan.projectType, {
+    targetDir: plan.targetDir,
+    dirName: plan.dirName,
+    pkInstall: plan.pkInstall,
+    packageManager: plan.packageManager
+  });
+  if (!cli.skipInstall) {
+    await installDependencies(plan.targetDir, plan.packageManager, plan.projectType);
+  }
+  if (plan.git) {
+    await initializeGit(plan.targetDir);
+  }
+  console.log(chalk.green("\n\u{1F389} Great! Your project has been created successfully! \u{1F389}"));
+  console.log("To view your project run:");
+  console.log("");
+  {
+    plan.targetDir != "." && console.log(chalk.yellow(`	cd ${plan.targetDir}`));
+  }
+  {
+    plan.packageManager == "npm" ? console.log(chalk.yellow(`	${plan.packageManager} run dev`)) : console.log(chalk.yellow(`	${plan.packageManager} dev`));
+  }
+  console.log("");
+}
+main();

package/dist/src/cli.js

@@ -0,0 +1,150 @@
+import { cancel, confirm, group, isCancel, select, text } from '@clack/prompts';
+import { Command } from 'commander';
+import path from 'path';
+import { SUPPORTED_PACKAGES, PROJECT_TYPES, SUPPORTED_CATEGORIES, SUPPORTED_PROJECTS } from './config';
+function resolveGitOption(command) {
+    const source = command.getOptionValueSource('git');
+    if (source === 'default')
+        return undefined;
+    return command.getOptionValue('git');
+}
+function validateProjectType(command, project) {
+    if (!project)
+        return;
+    if (!PROJECT_TYPES.includes(project)) {
+        command.error(`Invalid project. Use one of: ${PROJECT_TYPES.join(', ')}`);
+    }
+}
+function validatePackageManager(command, packageManager) {
+    if (!packageManager)
+        return;
+    const managers = SUPPORTED_PACKAGES.map(p => p.pkName);
+    if (!managers.includes(packageManager)) {
+        command.error(`Invalid package manager. Use one of: ${managers.join(', ')}`);
+    }
+}
+function detectPositionalProject(argv) {
+    const normalized = [...argv];
+    const candidate = normalized[2];
+    if (candidate && PROJECT_TYPES.includes(candidate)) {
+        normalized.splice(2, 1);
+        return { project: candidate, normalizedArgv: normalized };
+    }
+    return { normalizedArgv: normalized };
+}
+function isCanceled(value) {
+    if (isCancel(value)) {
+        cancel('Project creation cancelled.');
+        process.exit(0);
+    }
+}
+function getPackageManager() {
+    const ua = process.env.npm_config_user_agent ?? '';
+    const detected = SUPPORTED_PACKAGES.find(p => ua.startsWith(p.pkName)) ?? SUPPORTED_PACKAGES[0];
+    return detected;
+}
+export function parseCliArgs(argv) {
+    const program = new Command();
+    let parsed = null;
+    const { project, normalizedArgv } = detectPositionalProject(argv);
+    const managers = SUPPORTED_PACKAGES.map(p => p.pkName);
+    program
+        .name('create-stk')
+        .description('Opinionated, unified project scaffolding CLI.')
+        .argument('[directory]', 'Where your project will be stored')
+        .option('-p, --project <type>', `Project type: ${PROJECT_TYPES.join(' | ')}`)
+        .option('--pm <manager>', `Package manager: ${managers.join(' | ')}`)
+        .option('--git', 'Initialize git repository')
+        .option('--no-git', 'Skip git initialization')
+        .option('--skip-install', 'Skip dependency installation')
+        .option('--dry-run', 'Print the plan without creating files');
+    program.action((directory, options, command) => {
+        const projectOption = options.project;
+        const packageManager = options.pm;
+        validateProjectType(command, projectOption ?? project);
+        validatePackageManager(command, packageManager);
+        parsed = {
+            targetDir: directory,
+            project: projectOption ?? project,
+            packageManager,
+            git: resolveGitOption(command),
+            skipInstall: Boolean(options.skipInstall),
+            dryRun: Boolean(options.dryRun),
+        };
+    });
+    program.parse(normalizedArgv);
+    return (parsed ?? { project });
+}
+export async function resolvePlan(cli) {
+    let targetDir = cli.targetDir;
+    const project = cli.project ?? false;
+    if (!targetDir) {
+        const dir = await text({
+            message: 'Enter your project name:',
+            placeholder: '.',
+            defaultValue: '.',
+            validate(value) {
+                if (/\s/.test(value))
+                    return `Spaces are not allowed in the project name!`;
+            },
+        });
+        isCanceled(dir);
+        targetDir = dir.toString();
+    }
+    const dirName = targetDir === '.' ? path.basename(process.cwd()) : path.basename(path.resolve(targetDir));
+    const { pkName, pkInstall } = getPackageManager();
+    let projectType;
+    if (project) {
+        projectType = project;
+    }
+    else {
+        const projectCategory = await select({
+            message: 'What type of project do you want?',
+            options: SUPPORTED_CATEGORIES.map(p => ({ value: p, label: p })),
+        });
+        isCanceled(projectCategory);
+        projectType = await select({
+            message: `What ${projectCategory.toLowerCase()} template do you want to use?`,
+            options: SUPPORTED_PROJECTS.filter(p => p.category === projectCategory).map(p => ({
+                value: p.type,
+                label: p.name,
+            })),
+        });
+        isCanceled(projectType);
+    }
+    let packageManager;
+    if (cli.packageManager) {
+        packageManager = cli.packageManager;
+    }
+    else {
+        const selections = await group({
+            packageManager: () => select({
+                message: 'Which package manager would you like to use?',
+                initialValue: pkName,
+                options: SUPPORTED_PACKAGES.map(p => ({
+                    value: p.pkName,
+                    label: p.pkName,
+                    hint: pkName === p.pkName ? 'detected' : '',
+                })),
+            }),
+        }, {
+            onCancel: () => {
+                cancel('Project creation cancelled.');
+                process.exit(0);
+            },
+        });
+        packageManager = selections.packageManager;
+    }
+    let git;
+    if (typeof cli.git === 'boolean') {
+        git = cli.git;
+    }
+    else {
+        const gitChoice = await confirm({
+            message: 'Do you want to initialize a git repo?',
+        });
+        isCanceled(gitChoice);
+        git = gitChoice;
+    }
+    return { targetDir, dirName, projectType, packageManager, git, pkInstall };
+}

package/dist/src/config.js

@@ -0,0 +1,18 @@
+export const SUPPORTED_PACKAGES = [
+    { pkName: 'npm', pkInstall: 'npx' },
+    { pkName: 'pnpm', pkInstall: 'pnpx' },
+    { pkName: 'bun', pkInstall: 'bunx' },
+];
+export const TEMPLATE_CONFIG = [
+    { id: 'next', name: 'Next JS', category: 'Frontend' },
+    { id: 'nuxt', name: 'Nuxt', category: 'Frontend' },
+    { id: 'svelte', name: 'Svelte', category: 'Frontend' },
+    { id: 'node', name: 'Node', category: 'Backend' },
+];
+export const PROJECT_TYPES = TEMPLATE_CONFIG.map(t => t.id);
+export const SUPPORTED_CATEGORIES = [...new Set(TEMPLATE_CONFIG.map(t => t.category))];
+export const SUPPORTED_PROJECTS = TEMPLATE_CONFIG.map(t => ({
+    name: t.name,
+    type: t.id,
+    category: t.category,
+}));

package/dist/src/constants.js

@@ -0,0 +1,13 @@
+import { TEMPLATES } from './template-registry';
+export const SUPPORTED_PROJECTS = TEMPLATES.map(t => ({
+    name: t.name,
+    type: t.id,
+    category: t.category,
+}));
+export const SUPPORTED_PACKAGES = [
+    { pkName: 'npm', pkInstall: 'npx' },
+    { pkName: 'pnpm', pkInstall: 'pnpx' },
+    { pkName: 'bun', pkInstall: 'bunx' },
+];
+export const SUPPORTED_CATEGORIES = [...new Set(TEMPLATES.map(p => p.category))];
+export const PROJECT_TYPES = TEMPLATES.map(p => p.id);

package/dist/src/index.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import { parseCliArgs, resolvePlan } from './cli';
+import { executeTemplate, initializeGit, installDependencies } from './templates';
+function printDryRun(plan) {
+    console.log(JSON.stringify({ dryRun: true, plan }, null, 2));
+}
+async function main() {
+    const cli = parseCliArgs(process.argv);
+    const plan = await resolvePlan(cli);
+    if (cli.dryRun) {
+        printDryRun({
+            ...plan,
+            skipInstall: Boolean(cli.skipInstall),
+        });
+        return;
+    }
+    await executeTemplate(plan.projectType, {
+        targetDir: plan.targetDir,
+        dirName: plan.dirName,
+        pkInstall: plan.pkInstall,
+        packageManager: plan.packageManager,
+    });
+    if (!cli.skipInstall) {
+        await installDependencies(plan.targetDir, plan.packageManager, plan.projectType);
+    }
+    if (plan.git) {
+        await initializeGit(plan.targetDir);
+    }
+    console.log(chalk.green('\n🎉 Great! Your project has been created successfully! 🎉'));
+    console.log('To view your project run:');
+    console.log('');
+    {
+        plan.targetDir != '.' && console.log(chalk.yellow(`\tcd ${plan.targetDir}`));
+    }
+    {
+        plan.packageManager == 'npm'
+            ? console.log(chalk.yellow(`\t${plan.packageManager} run dev`))
+            : console.log(chalk.yellow(`\t${plan.packageManager} dev`));
+    }
+    console.log('');
+}
+main();